code stringlengths 2 1.05M |
|---|
import React, { PureComponent } from 'react'
import { AutoSuggestField, Button } from 'react-ui-core/src'
import { action } from '@storybook/addon-actions'
const ClearButton = props => (<Button {...props}>X</Button>)
const SubmitButton = props => (<Button {...props}>Submit</Button>)
class Example extends PureComponent {
constructor(props) {
super(props)
this.state = { suggestions: [] }
this.generateList = this.generateList.bind(this)
}
generateList(value) {
const length = value.length
const commonWords = [
'the', 'of', 'and', 'a', 'to', 'in', 'is', 'you', 'that', 'it', 'he', 'was',
'for', 'on', 'are', 'as', 'with', 'his', 'they', 'I', 'at', 'be', 'this',
'have', 'from', 'or', 'one', 'had', 'by', 'word', 'but', 'not', 'what',
'all', 'were', 'we', 'when', 'your', 'can', 'said', 'there', 'use', 'an',
'each', 'which', 'she', 'do', 'how', 'their', 'if', 'will', 'up', 'other',
'about', 'out', 'many', 'then', 'them', 'these', 'so', 'some', 'her', 'would',
'make', 'like', 'him', 'into', 'time', 'has', 'look', 'two', 'more', 'write',
'go', 'see', 'number', 'no', 'way', 'could', 'people', 'my', 'than',
'first', 'water', 'been', 'call', 'who', 'oil', 'its', 'now', 'find', 'long',
'down', 'day', 'did', 'get', 'come', 'made', 'may', 'part', 'test',
]
if (length < 1) {
this.setState({ suggestions: [] })
} else {
const suggestions = commonWords.filter(word => word.slice(0, length) === value)
this.setState({ suggestions })
}
}
render() {
return (
<AutoSuggestField
onInput={value => this.generateList(value)}
onAfterClear={action('after reset')}
onSubmit={action('On submit')}
suggestions={this.state.suggestions}
anchorField={{ placeholder: 'type a common letter or two...' }}
highlight
/>
)
}
}
export const AutoSuggestFieldSubmitButton = (
<AutoSuggestField
suggestions={['Option 1', 'Option 2', 'Option 3']}
anchorField={{ placeholder: 'enter a choice...' }}
submitButton={SubmitButton}
onSubmit={action('On submit')}
submitOnSelection={false}
/>
)
export const AutoSuggestFieldClearButton = (
<AutoSuggestField
suggestions={['Option A', 'Option B', 'Option C']}
clearButton={ClearButton}
onSubmit={action('On submit')}
onSelection={action('On selection')}
anchorField={{ placeholder: 'choose something...' }}
/>
)
export const AutoSuggestFieldDynamicResults = (
<Example />
)
|
import React, { Component } from 'react';
import {
View,
Text,
Image,
TouchableHighlight
} from 'react-native';
import moment from 'moment';
import _ from 'lodash';
import PureRenderMixin from 'react-addons-pure-render-mixin';
import Icon from 'react-native-vector-icons/Ionicons';
import { decodeHTML, getBloggerAvatar } from '../../common';
import { CommonStyles, ComponentStyles, StyleConfig } from '../../style';
class BlinkRow extends Component {
constructor(props) {
super(props);
this.shouldComponentUpdate = PureRenderMixin.shouldComponentUpdate.bind(this);
}
getBlinkInfo(){
let { blink } = this.props;
let blinkInfo = {};
if (blink && blink.Id) {
blinkInfo.Id = blink.Id;
blinkInfo.Content = decodeHTML(blink.Content);
blinkInfo.CommentCount = blink.CommentCount;
blinkInfo.Author= decodeHTML(blink.UserDisplayName);
blinkInfo.Avatar = getBloggerAvatar(blink.UserIconUrl);
blinkInfo.DateAdded = moment(blink.DateAdded).startOf('minute').fromNow();
}
return blinkInfo;
}
renderBlinkHeader(blinkInfo){
return (
<View style={ [ CommonStyles.flexRow, CommonStyles.flexItemsMiddle, CommonStyles.m_b_2 ] }>
<Image ref={view => this.imgView=view}
style={ [ ComponentStyles.avatar_mini, CommonStyles.m_r_2] }
source={ blinkInfo.Avatar }>
</Image>
<Text style={ [ CommonStyles.text_danger, CommonStyles.font_xs ] }>
{ blinkInfo.Author }
</Text>
</View>
);
}
renderBlinkContent(blinkInfo){
return (
<View style={ [ CommonStyles.m_b_2 ] }>
<Text style={ [CommonStyles.text_black, CommonStyles.font_sm, CommonStyles.line_height_md ] }>
{ blinkInfo.Content }
</Text>
</View>
);
}
renderBlinkMeta(blinkInfo){
return (
<View style={ [ CommonStyles.flexRow, CommonStyles.flexItemsBetween ] }>
<Text style={ [CommonStyles.text_gray, CommonStyles.font_ms] }>
{ blinkInfo.DateAdded }
</Text>
<View style={[ CommonStyles.flexRow, CommonStyles.flexItemsMiddle]}>
<Icon
name={ "ios-chatbubbles-outline" }
size= { StyleConfig.icon_size - 4 }
style = { [CommonStyles.background_transparent] }
color={ StyleConfig.color_primary } />
<Text style={ [ CommonStyles.text_primary, CommonStyles.m_l_1 ] }>
{ blinkInfo.CommentCount }
</Text>
</View>
</View>
);
}
render() {
const blinkInfo = this.getBlinkInfo();
return (
<TouchableHighlight
onPress={(e)=>{ this.props.onRowPress(blinkInfo) }}
underlayColor={ StyleConfig.touchable_press_color }
key={ blinkInfo.Id }>
<View style={ ComponentStyles.list }>
{ this.renderBlinkHeader(blinkInfo) }
{ this.renderBlinkContent(blinkInfo) }
{ this.renderBlinkMeta(blinkInfo) }
</View>
</TouchableHighlight>
)
}
}
export default BlinkRow;
|
'use strict';
const PNGToolkit = require('../../src/components/png-toolkit'),
PNG = require('pngjs').PNG;
describe('PNGToolkit', () => {
// creates a fake PNG with coordinates encoded into R and G colours, so we can inspect the clip easily
const initPic = function (width, height) {
const png = new PNG({width: width, height: height});
for (let y = 0; y < png.height; y++) {
for (let x = 0; x < png.width; x++) {
const idx = (png.width * y + x) << 2;
png.data[idx] = x;
png.data[idx + 1] = y;
}
}
return png;
},
clipCoords = function (png) {
const lastPixel = (png.width * png.height - 1) << 2;
return {
left: png.data[0],
top: png.data[1],
right: png.data[lastPixel],
bottom: png.data[lastPixel + 1]
};
};
let underTest,
config;
beforeEach(() => {
config = {};
underTest = new PNGToolkit(config);
});
describe('clip', () => {
let testPngBuffer;
beforeEach(() => {
testPngBuffer = PNG.sync.write(initPic(100, 50));
});
it('returns the unmodified original buffer if the clip corresponds to the actual size', done => {
underTest.clip(testPngBuffer, {width: 100, height: 50, x: 0, y: 0})
.then(r => expect(r).toBe(testPngBuffer))
.then(done, done.fail);
});
it('returns the clipped region if buffer is not the actual picture size', done => {
underTest.clip(testPngBuffer, {width: 50, height: 30, x: 10, y: 5})
.then(underTest.loadPng)
.then(clipCoords)
.then(coords => expect(coords).toEqual({left: 10, right: 59, top: 5, bottom: 34}))
.then(done, done.fail);
});
it('returns the correct clipped region if buffer is the actual picture size', done => {
underTest.clip(testPngBuffer, {width: 100, height: 50, x: 0, y: 0})
.then(underTest.loadPng)
.then(clipCoords)
.then(coords => expect(coords).toEqual({left: 0, right: 99, top: 0, bottom: 49}))
.then(done, done.fail);
});
});
});
|
import { createSelector } from 'reselect';
import { contractReceiptsPerTradeSelector, pipSizesPerTradeSelector, tradingTimesPerTradeSelector, feedLicensesPerTradeSelector, tradeParamsWithSymbolNameSelector } from '../BasicTradeSelectors';
export const tradeViewChartSelector = createSelector(
[
contractReceiptsPerTradeSelector,
tradingTimesPerTradeSelector,
pipSizesPerTradeSelector,
feedLicensesPerTradeSelector,
tradeParamsWithSymbolNameSelector,
],
(lastBoughtContracts, tradingTimes, pipSizes, licenses, params) =>
params.map((p, i) => ({
index: i,
contractForChart: lastBoughtContracts.get(i),
tradeForChart: p,
feedLicense: licenses.get(i),
pipSize: pipSizes.get(i),
tradingTime: tradingTimes.get(i),
}))
);
|
import m from "mithril";
import Stream from "mithril/stream";
export default class TagInput {
add (e, tags) {
if (e.keyCode === 13 && e.target.value) {
if (tags().indexOf(e.target.value) === -1) {
let tmp = tags();
tmp.push(e.target.value);
tags(tmp);
}
e.target.value = '';
}
}
del (tag, tags) {
let tmp = tags().filter(function(v) {
return v != tag;
});
tags(tmp);
}
view(vnode) {
return m(".tag-input.mar-t-xs",
[
vnode.attrs.tags().map((tag) => {
return m('span.badge.mar-r-xs.mar-b-xs',
{
style: {
"cursor": "pointer",
},
onclick: (e) => vnode.state.del(tag, vnode.attrs.tags)
},
tag
);
}),
m("input[type=text].pad-0", {
onkeypress: (e) => vnode.state.add(e, vnode.attrs.tags)
})
])
}
} |
module.exports = function(RED) {
if (false) { // Test for nodes compatibilities
throw "Info : not compatible";
}
function NodeConstructor(config) {
RED.nodes.createNode(this, config);
var node = this;
node.on("input", function(msg) {
node.send(msg);
//TODO
});
node.on("close", function() {
});
};
RED.nodes.registerType("azure-blob in", NodeConstructor);
} |
(function(){
angular.module('app').directive('newNote', function(){
return {
templateUrl: 'new-note.html',
controller: NewNoteController,
controllerAs: 'newNoteCtrl'
};
function NewNoteController(NoteService)
{
var vm = this;
vm.note = null;
vm.createNote = createNote;
vm.newNote = newNote;
function newNote()
{
vm.note = NoteService.getEmptyNote();
}
function createNote()
{
if((vm.note.title.length > 0) && (vm.note.message.length > 0))
{
NoteService.createNote(vm.note).then(function(newNote){
vm.notes.unshift(newNote);
});
}
vm.note = null;
}
}
});
})(); |
version https://git-lfs.github.com/spec/v1
oid sha256:58e291de12c87cb0748f737e3123ad446efcc6220d2f288ceb92bf87bab8a33f
size 1750
|
import React from "react";
import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import formInput from ".";
describe("formInput", () => {
const EnhancedInput = formInput("input");
describe("onChange and value", () => {
let onChangeSpy;
beforeEach(() => {
onChangeSpy = jest.fn();
});
afterEach(() => {
jest.resetAllMocks();
});
const INITIAL_VALUE = "initial value";
const UPDATED_VALUE = "uv";
it("should update input value after receiving new value through props", () => {
const { rerender } = render(<EnhancedInput value={INITIAL_VALUE} />);
const input = screen.getByRole("textbox");
expect(input).toHaveValue(INITIAL_VALUE);
rerender(<EnhancedInput value={UPDATED_VALUE} />);
expect(input).toHaveValue(UPDATED_VALUE);
});
it("should update input value after receiving new input.value through props", () => {
const { rerender } = render(
<EnhancedInput input={{ value: INITIAL_VALUE }} />,
);
const input = screen.getByRole("textbox");
expect(input).toHaveValue(INITIAL_VALUE);
rerender(<EnhancedInput input={{ value: UPDATED_VALUE }} />);
expect(input).toHaveValue(UPDATED_VALUE);
});
it("should call onChange callback when user types in", () => {
render(<EnhancedInput onChange={onChangeSpy} />);
const input = screen.getByRole("textbox");
expect(input).toHaveValue("");
userEvent.type(input, UPDATED_VALUE);
expect(input).toHaveValue(UPDATED_VALUE);
expect(onChangeSpy).toBeCalled();
});
it("should call input.onChange callback when user types in", () => {
render(<EnhancedInput input={{ onChange: onChangeSpy }} />);
const input = screen.getByRole("textbox");
expect(input).toHaveValue("");
userEvent.type(input, UPDATED_VALUE);
expect(input).toHaveValue(UPDATED_VALUE);
expect(onChangeSpy).toBeCalled();
});
it("should handle clear icon click by setting input value to empty string", () => {
render(
<EnhancedInput
onChange={onChangeSpy}
type="search"
value={INITIAL_VALUE}
/>,
);
const input = screen.getByRole("searchbox");
expect(input).toHaveValue(INITIAL_VALUE);
userEvent.click(screen.getByTestId("input-clear"));
expect(input).toHaveValue("");
expect(onChangeSpy).toBeCalled();
});
});
describe("focus and blur", () => {
let onFocus, onBlur;
beforeEach(() => {
onFocus = jest.fn();
onBlur = jest.fn();
});
afterEach(() => {
jest.resetAllMocks();
});
it("should call onFocus when input gets focused", () => {
render(<EnhancedInput onFocus={onFocus} />);
expect(onFocus).toBeCalledTimes(0);
userEvent.click(screen.getByRole("textbox"));
expect(onFocus).toBeCalled();
});
it("should call onBlur when input gets blurred", () => {
render(
<>
<EnhancedInput onBlur={onBlur} focused />
<button>click me</button>
</>,
);
expect(onBlur).toBeCalledTimes(0);
userEvent.click(screen.getByRole("button", { name: "click me" }));
expect(onBlur).toBeCalled();
});
it("should set input focus when component mounts", () => {
render(<EnhancedInput onFocus={onFocus} focused />);
expect(onFocus).toBeCalled();
});
it("should set input focus when focused property changes", () => {
const { rerender } = render(<EnhancedInput onFocus={onFocus} />);
const input = screen.getByRole("textbox");
expect(onFocus).toBeCalledTimes(0);
expect(input).not.toHaveClass("focused");
rerender(<EnhancedInput onFocus={onFocus} focused />);
expect(onFocus).toBeCalled();
expect(input).toHaveClass("focused");
});
describe("autoControlFocusedStyle", () => {
it("should set input focused style when focused changes to true ", () => {
const { rerender } = render(
<EnhancedInput autoControlFocusedStyle={false} />,
);
const input = screen.getByRole("textbox");
expect(input).not.toHaveClass("focused");
// User click should not apply the focused style
userEvent.click(input);
expect(input).not.toHaveClass("focused");
// Changing the property focused to true should apply the focused style
rerender(<EnhancedInput autoControlFocusedStyle={false} focused />);
expect(input).toHaveClass("focused");
// Changing the property focused to false should remove the focused style
rerender(<EnhancedInput autoControlFocusedStyle={false} />);
expect(input).not.toHaveClass("focused");
});
});
});
});
|
var class_tempest_1_1_shader_program_holder =
[
[ "BaseType", "class_tempest_1_1_shader_program_holder.html#acaa3176b59cf6ec1845005e47a10e632", null ],
[ "Source", "class_tempest_1_1_shader_program_holder.html#ab201c86c73d4133ae3053387647d7267", null ],
[ "ShaderProgramHolder", "class_tempest_1_1_shader_program_holder.html#af5bb32c7327c8985a3ce8198c15bf428", null ],
[ "~ShaderProgramHolder", "class_tempest_1_1_shader_program_holder.html#a11ba87c8b0fced014252852050a5b350", null ],
[ "compile", "class_tempest_1_1_shader_program_holder.html#a36cddb3771bf1e6a581a26928e2d5f90", null ],
[ "copy", "class_tempest_1_1_shader_program_holder.html#a72fb6ba0dfda3f6bb9fa14dae24bb89e", null ],
[ "deleteObject", "class_tempest_1_1_shader_program_holder.html#a5c5963d24c7c49d829307524eeaf9f66", null ],
[ "load", "class_tempest_1_1_shader_program_holder.html#af0c156b0cc8309c2902c102e725e32a4", null ],
[ "reset", "class_tempest_1_1_shader_program_holder.html#a83b197d3aea4c7ee59f45fd468805a6e", null ],
[ "restore", "class_tempest_1_1_shader_program_holder.html#a741c464d05880ee88d9bc2f175a1f246", null ],
[ "surfaceShader", "class_tempest_1_1_shader_program_holder.html#ae6266e8aa70ff800724c4a5568aec4a4", null ],
[ "Device", "class_tempest_1_1_shader_program_holder.html#a520fa05e0bf58785da428f7a0241eee2", null ],
[ "ShaderProgram", "class_tempest_1_1_shader_program_holder.html#aef20119bde6aff11ffd23f3ea2131b86", null ]
]; |
// Place all the behaviors and hooks related to the matching controller here.
// All this logic will automatically be available in application.js.
// You can use CoffeeScript in this file: http://coffeescript.org/
angular.module('receta',['wu.masonry', 'ui.bootstrap', 'ui-rangeSlider'])
.controller('DemoCtrl', function ($scope, $http, $modal) {
$scope.priceRange = {
min: 0,
max: 100
};
$scope.priceRangeFilter = function (brick) {
return brick.price >= $scope.priceRange.min && brick.price <= $scope.priceRange.max;
};
$http.get('/ads/all')
.success(function(data, status){
$scope.ads = JSON.stringify(data);
$scope.bricks = [];
$scope.priceRange.max = Math.max.apply(Math,data.map(function(o){return o.price;}))
$scope.priceRange.defaultMax = $scope.priceRange.max;
console.log($scope.priceRange.defaultMax);
for(var i = 0; i < 15; i++){
ad = data[Math.floor(Math.random() * data.length)];
console.log(ad);
$scope.bricks.push({
src: '/assets/' + ad.image + '.jpg?=' + i,
name: ad.name,
price:ad.price,
description: ad.description,
category_id: ad.category_id || '',
gender:ad.gender || ''
});
}
return;
for(var i = 0; i < data.length; i++){
ad = data[i];
$scope.bricks.push({
src: '/assets/' + ad.image + '.jpg?=' + i,
gender: 'F',
name: ad.name,
description: ad.description,
category_id: ad.category_id,
gender:ad.gender
});
}
});
$http.get('categories/all')
.success(function(data, status){
$scope.categories = data;
})
$scope.open = function (photo) {
var modalInstance = $modal.open({
templateUrl: 'myModalContent.html',
scope: $scope,
controller: 'ModalInstanceCtrl',
resolve: {
items: function () {
return photo;
},
photo: function(){
return photo;
}
}
});
}
$scope.openForm = function (photo) {
var modalInstance = $modal.open({
templateUrl: 'myModalContent2.html',
scope: $scope,
controller: 'ModalInstanceCtrl2',
resolve: {
categories: function(){
return $scope.categories
},
items: function () {
return photo;
},
photo: function(){
return photo;
}
}
});
}
})
.controller('ModalInstanceCtrl2', function ($scope, $modalInstance, items, categories) {
$scope.items = items;
$scope.categories = $scope.categories
$scope.selected = {
item: $scope.items,
};
$scope.categories = ["Boarding","Catering","Tutoring","Seminar","Car Rental"]
console.log(JSON.stringify($scope.categories))
$scope.ok = function () {
$modalInstance.close($scope.selected);
};
$scope.submit = function() {
$scope.submitted = true
console.log('submit');
};
$scope.cancel = function () {
$modalInstance.dismiss('cancel');
};
})
.controller('ModalInstanceCtrl', function ($scope, $modalInstance, items) {
$scope.items = items;
$scope.selected = {
item: $scope.items
};
console.log($scope.photo)
$scope.ok = function () {
$modalInstance.close($scope.selected.item);
};
$scope.cancel = function () {
$modalInstance.dismiss('cancel');
};
});
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _sparkPlugin = require('../lib/spark-plugin');
var _sparkPlugin2 = _interopRequireDefault(_sparkPlugin);
var _sparkCore = require('../spark-core');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**!
*
* Copyright (c) 2015-2017 Cisco Systems, Inc. See LICENSE file.
* @private
*/
var precedence = {
error: ['log'],
warn: ['error', 'log'],
info: ['log'],
debug: ['info', 'log'],
trace: ['debug', 'info', 'log']
};
/**
* Assigns the specified console method to Logger; uses `precedence` to fallback
* to other console methods if the current environment doesn't provide the
* specified level.
* @param {string} level
* @returns {Function}
*/
function wrapConsoleMethod(level) {
/* eslint no-console: [0] */
var impls = precedence[level];
if (impls) {
impls = impls.slice();
while (!console[level]) {
level = impls.pop();
}
}
return function wrappedConsoleMethod() {
var _console;
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
/* eslint no-invalid-this: [0] */
/* istanbul ignore if */
if (process.env.NODE_ENV === 'test' && this.spark && this.spark.device && this.spark.device.url) {
args.unshift(this.spark.device.url.slice(-3));
}
(_console = console)[level].apply(_console, args);
};
}
var Logger = _sparkPlugin2.default.extend({
namespace: 'Logger',
error: wrapConsoleMethod('error'),
warn: wrapConsoleMethod('warn'),
log: wrapConsoleMethod('log'),
info: wrapConsoleMethod('info'),
debug: wrapConsoleMethod('debug'),
trace: wrapConsoleMethod('trace')
});
(0, _sparkCore.registerPlugin)('logger', Logger);
exports.default = Logger;
//# sourceMappingURL=logger.js.map
|
module.exports = {
"key": "rufflet",
"moves": [
{
"learn_type": "tutor",
"name": "roost"
},
{
"learn_type": "tutor",
"name": "superpower"
},
{
"learn_type": "tutor",
"name": "heat-wave"
},
{
"learn_type": "tutor",
"name": "sleep-talk"
},
{
"learn_type": "tutor",
"name": "snore"
},
{
"learn_type": "machine",
"name": "work-up"
},
{
"learn_type": "machine",
"name": "retaliate"
},
{
"learn_type": "level up",
"level": 50,
"name": "sky-drop"
},
{
"learn_type": "machine",
"name": "round"
},
{
"learn_type": "level up",
"level": 14,
"name": "hone-claws"
},
{
"learn_type": "level up",
"level": 32,
"name": "defog"
},
{
"learn_type": "machine",
"name": "shadow-claw"
},
{
"learn_type": "level up",
"level": 59,
"name": "brave-bird"
},
{
"learn_type": "level up",
"level": 41,
"name": "air-slash"
},
{
"learn_type": "machine",
"name": "u-turn"
},
{
"learn_type": "level up",
"level": 37,
"name": "tailwind"
},
{
"learn_type": "machine",
"name": "pluck"
},
{
"learn_type": "machine",
"name": "bulk-up"
},
{
"learn_type": "level up",
"level": 23,
"name": "aerial-ace"
},
{
"learn_type": "machine",
"name": "rock-tomb"
},
{
"learn_type": "level up",
"level": 46,
"name": "crush-claw"
},
{
"learn_type": "machine",
"name": "facade"
},
{
"learn_type": "machine",
"name": "rock-smash"
},
{
"learn_type": "machine",
"name": "sunny-day"
},
{
"learn_type": "machine",
"name": "rain-dance"
},
{
"learn_type": "machine",
"name": "hidden-power"
},
{
"learn_type": "machine",
"name": "frustration"
},
{
"learn_type": "machine",
"name": "return"
},
{
"learn_type": "machine",
"name": "attract"
},
{
"learn_type": "machine",
"name": "swagger"
},
{
"learn_type": "level up",
"level": 19,
"name": "scary-face"
},
{
"learn_type": "machine",
"name": "protect"
},
{
"learn_type": "machine",
"name": "substitute"
},
{
"learn_type": "level up",
"level": 28,
"name": "slash"
},
{
"learn_type": "machine",
"name": "rock-slide"
},
{
"learn_type": "machine",
"name": "rest"
},
{
"learn_type": "machine",
"name": "double-team"
},
{
"learn_type": "machine",
"name": "toxic"
},
{
"learn_type": "machine",
"name": "strength"
},
{
"learn_type": "level up",
"level": 1,
"name": "peck"
},
{
"learn_type": "level up",
"level": 1,
"name": "leer"
},
{
"learn_type": "level up",
"level": 64,
"name": "thrash"
},
{
"learn_type": "level up",
"level": 5,
"name": "fury-attack"
},
{
"learn_type": "machine",
"name": "fly"
},
{
"learn_type": "level up",
"level": 55,
"name": "whirlwind"
},
{
"learn_type": "level up",
"level": 10,
"name": "wing-attack"
},
{
"learn_type": "machine",
"name": "cut"
}
]
}; |
module.exports = {"NotoSansLydian":{"normal":"NotoSansLydian-Regular.ttf","bold":"NotoSansLydian-Regular.ttf","italics":"NotoSansLydian-Regular.ttf","bolditalics":"NotoSansLydian-Regular.ttf"}}; |
'use strict';
const Webpack = require('webpack');
const WebpackDevMiddleware = require('webpack-dev-middleware');
exports.register = (server, options, next) => {
const config = options.config;
const compiler = Webpack(config);
server.app.webpackCompiler = compiler;
const middleware = WebpackDevMiddleware(compiler, options.options);
server.ext('onRequest', (request, reply) => {
const req = request.raw.req;
const res = request.raw.res;
middleware(req, res, (err) => {
if (err) {
return reply(err);
}
return reply.continue();
});
});
next();
};
exports.register.attributes = {
pkg: require('./package.json')
};
|
'use strict';
var fs = require('fs'),
_ = require('lodash'),
colors = require('cli-color'),
utils = require('./utils.js');
function doSnapShot(roadMapPath, urlPrefix) {
var target,
payload,
response,
url;
var roadMap = utils.getRoadMapFromPath(roadMapPath);
console.log('Processing road map file "' + roadMapPath + '":');
var bootInfo = utils.getBootInfo();
var souvenirPath = utils.getSouvenirPathForRoadMapPath(roadMapPath);
var fixTestcases = utils.getTestcases();
if (_.isEmpty(fixTestcases)) {
utils.mkEmptyDirSync(souvenirPath);
}
var no = 0,
skipped = 0,
failed = 0,
fail = [],
bad = [];
for (target in roadMap) {
no++;
if (!_.isEmpty(fixTestcases) && !_.contains(fixTestcases, no)) {
skipped++;
continue;
}
console.log('');
console.log( 'Request #' + no + ' ==================');
payload = roadMap[target];
url = urlPrefix + target;
response = utils.getHttpResponse(url, payload, bootInfo.getHeaders());
if (_.isNull(response)) {
failed++;
fail.push(no);
console.log('ERROR! Request timed out!');
continue;
}
var targetFilePath = utils.getSouvenirPathForTarget(souvenirPath, target);
fs.writeFileSync(targetFilePath, JSON.stringify(response));
let code = response.statusCode;
if ((code >= 400) && (code < 500)) {
code = colors.magenta(code);
bad.push(no);
} else if (code >= 500) {
code = colors.red(code);
failed++;
fail.push(no);
} else {
code = colors.green(code);
}
console.log(' --> ' + code + ': Stored ' + response.body.length + ' bytes as souvenir');
}
console.log('');
console.log('==========================');
let status = [];
let succ = no - skipped - failed - bad.length;
if (skipped > 0) {
status.push(colors.blue(skipped + ' skipped'));
}
if (bad.length > 0) {
status.push(colors.magenta(bad.length + ' bad'));
}
if (failed > 0) {
status.push(colors.red(failed + ' failed'))
}
if (succ > 0) {
status.push(colors.green(succ + ' successful'))
}
console.log(' Summary: ' + no + ' requests found [ ' + status.join(', ') + ' ]');
if (fail.length > 0) {
console.log(colors.red(' Failed requests: ' + fail.join(',')));
}
if (bad.length > 0) {
console.log(colors.magenta(' Bad requests: ' + bad.join(',')));
}
}
var args = utils.getArguments();
if (args.hasOwnProperty('args') || args.length === 1) {
var roadMapPath = utils.getRoadMapPath();
var baseUrl = utils.getBaseUrlFromArguments();
doSnapShot(roadMapPath, baseUrl);
} else {
args.printHelp();
} |
import React from "react"
import CommentList from "./CommentList"
import CommentForm from "./CommentForm"
export default class CommentBox extends React.Component {
constructor(props) {
super(props)
this.state = {
data: []
}
}
componentDidMount() {
// Pull data from server.
}
handleCommentSubmit(comment) {
var comments = this.state.data;
var newComments = comments.concat([comment])
this.setState({data: newComments})
// Send data to server.
}
render() {
return(
<div className="commentBox">
<h2>Comments</h2>
<CommentForm onCommentSubmit={this.handleCommentSubmit.bind(this)} />
<CommentList data={this.state.data} />
</div>
)
}
}
|
'use strict';
var Dispatcher = require('./Dispatcher');
var merge = require('react/lib/merge');
/**
* Bridge function between the views (which will
* be generating some actions) and the
* dispatcher, 'painting' the action as a
* 'VIEW_ACTION' so that whoever will receive
* the payload will know how to deal with this
* kind of action.
*/
var AppDispatcher = merge(Dispatcher.prototype, {
handleViewAction (action) {
this.dispatch({
source: 'VIEW_ACTION',
action: action
});
}
});
module.exports = AppDispatcher;
|
/* eslint no-console:"off" */
const {resolve} = require('path');
const webpack = require('webpack');
const {getIfUtils, removeEmpty} = require('webpack-config-utils');
module.exports = env => {
const {ifProd, ifNotProd} = getIfUtils(env);
const config = {
context: resolve('src'),
entry: {
app: './index.js',
},
output: {
path: 'dist',
filename: 'transifex-api.min.js',
libraryTarget: 'umd',
library: 'TransifexApi',
},
devtool: ifProd('source-map', 'eval'),
module: {
loaders: [
{test: /\.js$/, loaders: ['babel-loader'], exclude: /node_modules/}
],
},
plugins: removeEmpty([
new webpack.DefinePlugin({
'process.env': {
NODE_ENV: ifProd('"production"', '"development"'),
},
})
]),
}
if (env.debug) {
console.log(config);
debugger // eslint-disable-line
}
return config;
};
|
IntlMessageFormat.__addLocaleData({locale:"tk",pluralRuleFunction:function(e,t){return t?"other":1==e?"one":"other"}}); |
//think about a better way to organize the data in this, maybe using forms--as it it seems unlikely to work
$(document).ready(function(){
var thisNumber = '';
var lastNumber = '';
var operation;
var calcDisplay = document.getElementById('calcDisplay');
//build the calculator
var firstRow =[['on/c','on'], ['ce', 'ce'], ['mrc', 'mrc'], ['m+', 'mplus'], ['m-', 'mminus']];
var secondRow = [['7', '55'], ['8', '56'], ['9', '57'], ['×', 'multiply'], ['÷', 'divide']];
var thirdRow = [['4', '52'], ['5', '53'], ['6', '54'], ['-', 'subract'], ['√', 'sqrt']];
var fourthRow = [['1', '49'], ['2', '50'], ['3', '51'], ['+', 'add'], ['%', 'percent']];
var fifthRow = [['0','48'], ['.', '46'], ['±', 'plusminus'], ['=', 'equals']];
var buttonList = [firstRow, secondRow, thirdRow, fourthRow, fifthRow];
function setup(){
//build the table for the buttons
var buttonContainer = document.getElementById('buttonContainer');
var buttonTable = document.createElement('table');
buttonContainer.appendChild(buttonTable);
//iterate through button rows
for (var i = 0; i < buttonList.length; i++){
var buttonRow = document.createElement('tr');
buttonTable.appendChild(buttonRow);
var thisRow = buttonList[i];
//iterate through button columns
//second element in each button is id of button, class of containing td
for (var j = 0; j < thisRow.length; j++){
var thisRowEl = document.createElement('td');
thisRowEl.className = thisRow[j][1];
buttonRow.appendChild(thisRowEl);
var thisButton = document.createElement('button');
thisButton.className = 'button';
thisButton.id = thisRow[j][1];
thisButton.innerHTML = thisRow[j][0];
thisRowEl.appendChild(thisButton);
}
$('.add').attr('rowspan','2');
}
}
setup();
//build event listeners for keyboard and mouseclicks
var calcContainer = document.getElementById('calcContainer');
calcContainer.addEventListener('click', function(e){
doButtonAction(e, false);
})
document.addEventListener('keydown', function(e){
doButtonAction(e,true);
})
//functions for key functionality
function doButtonAction(e, inputType){
if (inputType){
var keycodeId = e.keyCode;
console.dir(e);
} else {
var keycodeId = e.target.id;
}
var shiftFlag = e.shiftKey;
console.log('Shift was pressed: ' + shiftFlag);
console.log('keycodeId is ' + keycodeId);
//if a number key was pressed of if a number button was pushed
switch (keycodeId){
case 67:
keycodeId='on';
break;
case 187:
if (shiftFlag){
keycodeId = 'plus';
} else {
keycodeId = 'equals';
}
break;
case 189:
keycodeId = 'subtract';
break;
case 56:
if (shiftFlag){
keycodeId = 'multiply';
}
break;
case 191:
keycodeId = 'divide';
break;
case 190:
keycodeId = 46;
case 13:
keycodeId = 'equals';
break
}
//add functionality to calc
if (Number(keycodeId) && Number(keycodeId) < 58 && Number(keycodeId) > 47 || Number(keycodeId) === 46){
thisNumber += String.fromCharCode(keycodeId);
}
//on clear
if (keycodeId === 'on'){
thisNumber = '';
lastNumber = '';
}
//on plus this doesn't work right now
if (keycodeId === 'plus'){
operation = 'plus';
var tresult = equals();
lastNumber = thisNumber;
thisNumber = tresult;
}
//update display at finish
calcDisplay.textContent = thisNumber;
}
function equals(){
var result;
if (operation === 'plus'){
result = (+thisNumber + +lastNumber).toString();
console.log(result);
}
lastNumber ='';
return result;
}
});
|
/*
* NoPromise: Promise A+ compliant implementation, also with ES6 interface
* Copyright 2016 Avi Halachmi (:avih) http://github.com/avih/nopromise
* License: MIT
*
* Interface, e.g. after var Promise = require("nopromise") :
* new Promise(function executor(resolveFn, rejectFn) { ... })
* Promise.prototype.then(onFulfilled, onRejected)
* Promise.prototype.catch(onRejected)
* Promise.prototype.finally(onFinally)
* Promise.resolve(value)
* Promise.reject(reason)
* Promise.all(iterator)
* Promise.race(iterator)
*
* Legacy interface is also supported:
* Promise.defer() or Promise.deferred()
* Promise.prototype.resolve(value)
* Promise.prototype.reject(reason)
*/
(function(G){
// Promise terminology:
// State: begins with pending, may move once to fulfilled+value/rejected+reason.
// Settled: at its final fulfilled/rejected state.
// Resolved = sealed fate: settled or (pending and) follows another thenable T.
// resolved + pending = follows only T - ignores later resolve/reject calls.
// Thenable = has .then(): promise but not necessarily our implementation.
// Note: the API has reject(r)/resolve(v) but not fulfill(v). that is because:
// resolve(v) already fulfills with value v if v is not a promise.
// if v is a promise then it should be followed - not be a fulfilled value.
// hence resolve(v) either fulfills with v, or follows + seals the fate to v.
var globalQ,
async,
staticNativePromise,
FULFILLED = 1,
REJECTED = 2,
FUNCTION = "function";
// Try to find the fastest asynchronous scheduler for this environment:
// setImmediate -> native Promise scheduler -> setTimeout
async = this.setImmediate; // nodejs, IE 10+
try {
staticNativePromise = Promise.resolve();
async = async || function(f) { staticNativePromise.then(f) }; // Firefox/Chrome
} catch (e) {}
async = async || setTimeout; // IE < 10, others
// The invariant between internalAsync and dequeue is that if globalQ is thuthy,
// then a dequeue is already scheduled and will execute globalQ asynchronously,
// otherwise, globalQ needs to be created and dequeue needs to be scheduled.
// The elements (functions) of the globalQ array need to be invoked in order.
function dequeue() {
var f, tmp = globalQ.reverse();
globalQ = 0;
while (f = tmp.pop())
f();
}
// This is used throughout the implementation as the asynchronous scheduler.
// While satisfying the contract to invoke f asynchronously, it batches
// individual f's into a single group which is later iterated synchronously.
function internalAsync(f) {
if (globalQ) {
globalQ.push(f);
} else {
globalQ = [f];
async(dequeue);
}
}
// fulfill/reject a promise if it's pending, else no-op.
function settle(p, state, value) {
if (!p._state) {
p._state = state;
p._output = value;
var f, arr = p._resolvers;
if (arr) {
// The case where `then` is called many times for the same promise
// is rare, so for simplicity, we're not optimizing for it, or else
// if globalQ is empty, we can just do: globalQ = p._resolvers;
arr.reverse();
while (f = arr.pop())
internalAsync(f);
}
}
}
function reject(promise, reason) {
promise._sealed || promise._state || settle(promise, REJECTED, reason);
}
// a promise's fate may be set only once. fullfill/reject trivially set its fate
// (and also settle it), but resolving it with another promise P must also seal
// its fate, such that no later fulfill/reject/resolve are allowed to affect its
// fate - onlt P will do so once/if it settles.
// promise here is always NoPromise, but x might be a value/NoPromise/thenable.
function resolve(promise, x, decidingFate) {
if (promise._state || (promise._sealed && !decidingFate))
return;
// seal fate. only this instance of resolve can settle it [recursively]
promise._sealed = 1;
var then,
done = 0;
try {
if (x == promise) {
settle(promise, REJECTED, TypeError());
} else if (x instanceof NoPromise && x._state) {
// we can settle synchronously if we know that x is settled and also
// know how to adopt its state, which we do when x is NoPromise.
settle(promise, x._state, x._output);
// Check for generic thenable... which includes unsettled NoPromise.
} else if ((x && typeof x == "object" || typeof x == FUNCTION)
&& typeof (then = x.then) == FUNCTION) {
then.call(x, function(y) { done++ || resolve(promise, y, 1) }, // decidingFate
function(r) { done++ || settle(promise, REJECTED, r)});
} else {
settle(promise, FULFILLED, x);
}
} catch (e) {
done++ || settle(promise, REJECTED, e);
}
}
// Other than the prototype methods, the object may also have:
// ._state : 1 if fulfilled, 2 if rejected (doesn't exist otherwise).
// ._output : value if fulfilled, reason if rejected (doesn't exist otherwise).
// ._resolvers: array of functions (closures) for each .then call while pending (if there were any).
// ._sealed : new resolve/reject are ignored (exists if resolve was called).
NoPromise.prototype = {
// Each call to `then` returns a new NoPromise object and creates a closure
// which is used to resolve it after then's this is fulfilled/rejected.
then: function(onFulfilled, onRejected) {
var _self = this,
promise2 = new NoPromise;
this._state ? internalAsync(promise2Resolver)
: this._resolvers ? this._resolvers.push(promise2Resolver)
: this._resolvers = [promise2Resolver];
return promise2;
// Invoked asynchronously to `then` and after _self is settled.
// _self._state here is FULFILLED/REJECTED
function promise2Resolver() {
var handler = _self._state == FULFILLED ? onFulfilled : onRejected;
// no executor for promise2, so not yet sealed, but the legacy API
// can make it already sealed here, e.g. p2=p.then(); p2.resolve(X)
// So we still need to check ._sealed before settle(..) below
if (typeof handler != FUNCTION) {
promise2._sealed || settle(promise2, _self._state, _self._output);
} else {
try {
resolve(promise2, handler(_self._output));
} catch (e) {
reject(promise2, e);
}
}
}
}, // then
catch: function(onRejected) {
return this.then(undefined, onRejected);
},
// P.finaly(fn) returns a promise X, and calls fn after P settles as S.
// if fn throws E: X is rejected with E.
// Else if fn returns a promise F: X is settled once F is settled:
// If F is rejected with FJ: X is rejected with FJ.
// Else: X settles as S [ignoring fn's retval or F's fulfillment value]
finally: function(onFinally) {
function fin_noargs() { return onFinally() }
var fn;
return this
.then(function(v) { fn = function() { return v } },
function(r) { fn = function() { throw r } })
.then(fin_noargs, fin_noargs)
.then(function finallyOK() { return fn() });
},
}
// CTOR:
// return new NoPromise(function(resolve, reject) { setTimeout(function() { resolve(42); }, 100); });
function NoPromise(executor) {
if (executor) { // not used inside 'then' nor by the legacy interface
var self = this;
try {
executor(function(v) { resolve(self, v) },
function(r) { reject(self, r) });
} catch (e) {
reject(self, e);
}
}
}
// detect a generic thenable - same logic as at resolve(). may throw.
function is_thenable(x) {
return ((x && typeof x == "object") || typeof x == FUNCTION)
&& typeof x.then == FUNCTION;
}
// Static methods
// --------------
// Returns a resolved/rejected promise with specified value(or promise)/reason
NoPromise.resolve = function(v) {
return new NoPromise(function(res, rej) { res(v) });
};
NoPromise.reject = function(r) {
return new NoPromise(function(res, rej) { rej(r) });
};
// For .all and .race: we support iterators as array or array-like, and slack
// when it comes to throwing on invalid iterators (we only try [].slice.call).
// Static NoPromise.all(iter) returns a promise X.
// If iter is empty: X fulfills synchronously to an empty array.
// Else for the first promise in iter which rejects with J: X rejects a-sync with J.
// Else (all fulfill): X fulfills a-sync to an array of iter's fulfilled-values
// (non-promise values are considered already fulfilled with that value).
NoPromise.all = function(iter) {
Array.isArray(iter) || (iter = [].slice.call(iter));
var len = iter.length;
if (!len)
return NoPromise.resolve([]); // empty fulfills synchronously
return new NoPromise(function(allful, allrej) {
var rv = [], pending = 0;
function fulOne(i, val) { rv[i] = val; --pending || allful(rv); }
iter.forEach(function(v, i) {
if (is_thenable(v)) {
pending++;
v.then(fulOne.bind(null, i), allrej);
} else {
rv[i] = v;
}
});
// Non empty but without promises - fulfills a-sync
if (!pending)
NoPromise.resolve(rv).then(allful);
});
}
// Static NoPromise.race(iter) returns a promise X:
// If iter is empty: X never settles.
// Else: X settles always a-sync and mirrors the first promise in iter which settles.
// (non-promise values are considered already fulfilled with that value).
NoPromise.race = function(iter) {
return new NoPromise(function(allful, allrej) {
Array.isArray(iter) || (iter = [].slice.call(iter));
iter.some(function(v, i) {
if (is_thenable(v)) {
v.then(allful, allrej);
} else {
NoPromise.resolve(v).then(allful);
return true; // continuing would end up no-op
}
});
});
}
// Legacy interface - not used elsewhere in NoPromise, used by the test suit (below)
// var d = NoPromise.defer(); setTimeout(function() { d.resolve(42); }, 100); return d.promise;
NoPromise.defer = function() {
var d = new NoPromise;
return d.promise = d;
};
NoPromise.prototype.resolve = function(value) {
resolve(this, value);
}
NoPromise.prototype.reject = function(reason) {
reject(this, reason);
}
// End of legacy interface
// Promises/A+ Compliance Test Suite
// https://github.com/promises-aplus/promises-tests
// nopromise.js itself can be the adapter: promises-aplus-tests ./nopromise.js
// The only required modification is that it wants different names - dup below.
NoPromise.deferred = NoPromise.defer; // Static legacy API
NoPromise.resolved = NoPromise.resolve; // Static standard, optional but tested
NoPromise.rejected = NoPromise.reject; // Static standard, optional but tested
// The tests also use the legacy dynamic API: prototype.resolve(v)/.reject(r)
try {
module.exports = NoPromise;
} catch (e) {
G.NoPromise = NoPromise;
}
})( // used to setup a global NoPromise - not when using require("nopromise")
typeof global != "undefined" ? global :
typeof window != "undefined" ? window : this)
|
/**
* String utilities
* this one is compatible with frontend too, so written in a way it can be
* included in frontend, and accessible via window.Util_Str
*/
(function (w) {
'use strict';
w.Util_Str = {
/**
* capitlise
* @param str
* @returns {string}
*/
capitalise(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
},
/**
* camel case
* @param str
* @param delimiter
* @returns {string}
*/
camelCase(str, delimiter) {
delimiter = (typeof delimiter === 'undefined') ? '_' : delimiter;
let tmpAr = str.split(delimiter);
let output = '';
const S = this;
tmpAr.forEach(function (el) {
output += S.capitalise(el);
});
return output;
},
/**
* simple template engine
* replaces data values inside template (use {var})
* @param tmp
* @param data
*/
template(tmp, data) {
let output = tmp;
for (let k in data) {
let val = data[k];
// add slash when it's $
if (k.slice(0, 1) == '$') {
k = "\\" + k;
}
output = output.replace(new RegExp('{' + k + '}', 'g'), val);
}
return output;
}
};
if (typeof module === 'object') {
module.exports = w.Util_Str;
}
})(this);
|
angular.module('conrep', ['ui.bootstrap'])
.controller('ProjectPickerController', function($scope, $dialog) {
//initial load
$scope.options = [{ name: "Wells Fargo - CORE", value: 1, description:"Wells Description",
startDate:"2013-03-20", endDate:"2013-08-20"},
{ name: "Another project", value: 2, description: "Another Description",
startDate:"2013-01-20", endDate:"2013-09-20"}];
$scope.selectedOption = null;
$scope.showAddEditProject = function (action) {
$scope.isEdit = function(){
return action == "Edit";
}
$scope.dialogTitle =action;
var selectedOption = null;
if (action !== "Add"){
selectedOption =$scope.selectedOption;
}else{
$scope.project = {};
}
var items = $scope.options;
var options = {
backdropFade: true,
dialogFade: true,
dialogClass: 'modal projectDialog',
resolve: {
selectedOption: function () { return selectedOption; },
items: function () { return items; },
$scope: function () { return $scope; }
}
};
var dialog = $dialog.dialog(options).open('projectDialog.html', 'DialogAddEditController');
};
})
.controller('DialogAddEditController', function ($scope, dialog, items, selectedOption) {
if(selectedOption != null){
$scope.project = {};
$scope.project.name = selectedOption.name;
$scope.project.description = selectedOption.description;
$scope.project.value = selectedOption.value;
$scope.project.startDate = selectedOption.startDate;
$scope.project.endDate = selectedOption.endDate;
}
$scope.saveProject = function (project){
if (project !== undefined){
if (project.name == undefined) {
alert("Missing Name!");
} else {
if(selectedOption !== null){
angular.forEach(items, function( object, key){
if (object.value === project.value){
items[key] = project;
return false;
}
});
alert("Project successfully updated!!");
} else{
items.push({name:project.name, value: items.length + 1, description: project.description,
startDate:project.startDate, endDate:project.endDate});
alert("Project successfully added!!");
}
dialog.close(project);
$scope.selectedOption = null;
}
}else {
alert("Missing Name or Description!!");
}
}
$scope.cancelProject = function (){
dialog.close();
$scope.selectedOption = null;
}
$scope.removeProject = function (project, event){
if (project !== undefined){
if(selectedOption !== undefined){
var deleteProject = confirm('Are you sure to delete this project?');
if (deleteProject) {
angular.forEach(items, function( object, key){
if (object.value === project.value){
items.splice(key ,1);
return false;
}
});
alert("Project successfully deleted!!");
dialog.close(project);
$scope.selectedOption = null;
}
}
}
}
})
.directive('ngConfirmClick', [
function(){
return {
link: function (scope, element, attr) {
var msg = attr.ngConfirmClick || "Are you sure?";
var clickAction = attr.confirmedClick;
element.bind('click',function (event) {
if ( window.confirm(msg) ) {
scope.$eval(clickAction)
}
});
}
};
}]);
|
/**
* StereoCamera
*/
import {
Camera,
OBJECT_TYPE,
Object3D,
TEXEL_ENCODING_TYPE
} from "../../../build/zen3d.module.js";
var StereoCamera = function() {
Object3D.call(this);
this.type = OBJECT_TYPE.CAMERA;
this.cameraL = new Camera();
this.cameraR = new Camera();
this.near = 1;
this.far = 1000;
}
StereoCamera.prototype = Object.create(Object3D.prototype);
StereoCamera.prototype.constructor = StereoCamera;
Object.defineProperties(StereoCamera.prototype, {
gammaFactor: {
get: function() {
return this.cameraL.gammaFactor;
},
set: function(value) {
this.cameraL.gammaFactor = value;
this.cameraR.gammaFactor = value;
}
},
gammaInput: {
get: function() {
console.warn("StereoCamera: .gammaInput has been removed. Use texture.encoding instead.");
return false;
},
set: function(value) {
console.warn("StereoCamera: .gammaInput has been removed. Use texture.encoding instead.");
}
},
gammaOutput: {
get: function() {
console.warn("StereoCamera: .gammaOutput has been removed. Use .outputEncoding or renderTarget.texture.encoding instead.");
return this.cameraL.outputEncoding == TEXEL_ENCODING_TYPE.GAMMA;
},
set: function(value) {
console.warn("StereoCamera: .gammaOutput has been removed. Use .outputEncoding or renderTarget.texture.encoding instead.");
if (value) {
this.cameraL.outputEncoding = TEXEL_ENCODING_TYPE.GAMMA;
this.cameraR.outputEncoding = TEXEL_ENCODING_TYPE.GAMMA;
} else {
this.cameraL.outputEncoding = TEXEL_ENCODING_TYPE.LINEAR;
this.cameraR.outputEncoding = TEXEL_ENCODING_TYPE.LINEAR;
}
}
},
outputEncoding: {
get: function() {
return this.cameraL.outputEncoding;
},
set: function(value) {
this.cameraL.outputEncoding = value;
this.cameraR.outputEncoding = value;
}
}
});
export { StereoCamera }; |
chesskid.module
.controller('play', function($scope) {
}) |
import actionTypes from '../actions/actionTypes';
export const addTransaction = (channel, payload) => dispatch => {
dispatch({ type: actionTypes.ADD_TRANSACTION_REQUEST });
channel
.push('new_transaction', payload)
.receive('error', () => {
dispatch({ type: actionTypes.ADD_TRANSACTION_FAILURE });
});
};
export const addTransactions = payload => {
// TODO: don't add duplicate transactions, update them instead.
// This can happen when a channel join() happens after a network
// reconnection, and the user already has transactions in the
// store.
return {
payload,
type: actionTypes.ADD_TRANSACTIONS,
};
};
export const deleteTransaction = (channel, payload) => dispatch => {
dispatch({ type: actionTypes.DELETE_TRANSACTION_REQUEST });
channel
.push('delete_transaction', payload)
.receive('error', () => {
dispatch({ type: actionTypes.DELETE_TRANSACTION_FAILURE });
});
};
export const saveTransaction = (channel, payload) => dispatch => {
dispatch({ type: actionTypes.SAVE_TRANSACTION_REQUEST });
channel
.push('update_transaction', payload)
.receive('error', () => {
dispatch({ type: actionTypes.SAVE_TRANSACTION_FAILURE });
});
};
export const transactionAdded = payload => {
return {
payload,
type: actionTypes.TRANSACTION_ADDED,
};
};
export const transactionDeleted = payload => {
return {
payload,
type: actionTypes.TRANSACTION_DELETED,
};
};
export const transactionUpdated = payload => {
return {
payload,
type: actionTypes.TRANSACTION_UPDATED,
};
};
export const updateTransactionAmount = payload => {
return {
payload,
type: actionTypes.UPDATE_TRANSACTION_AMOUNT,
};
};
export const updateTransactionCategory = payload => {
return {
payload,
type: actionTypes.UPDATE_TRANSACTION_CATEGORY,
};
};
export const updateTransactionDate = payload => {
return {
payload,
type: actionTypes.UPDATE_TRANSACTION_DATE,
};
};
export const updateTransactionName = payload => {
return {
payload,
type: actionTypes.UPDATE_TRANSACTION_NAME,
};
};
|
var React = require('react')
var {RouteHandler} = require('react-router')
var Reddit = React.createClass({
displayName: 'Reddit',
statics: {
fetchData: require('../controllers/reddit')
},
render: function() {
var listings = this.props.redditListings && this.props.redditListings.map(function(listing) {
return (
<li key={listing.data.url}>
<a href={listing.data.url}>{listing.data.title}</a>
</li>
)
})
return (
<div>
<h1>reddit listings</h1>
<ul>
{listings}
</ul>
</div>
)
}
})
module.exports = Reddit
|
const gulp = require('gulp');
const mocha = require('gulp-mocha');
const terser = require('gulp-terser');
const concat = require('gulp-concat');
const minifyCss = require('gulp-cssnano');
const ejsmin = require('gulp-ejsmin');
const through = require('through2')
gulp.task('testEnv', (done) => {
process.env.spec = true;
done();
});
gulp.task('default', gulp.series('testEnv', test = (done) => {
gulp.src('spec/index.js', {read: false})
.pipe(mocha({require: ['mocha-clean'], reporter: 'nyan', exit: true}))
done();
}));
gulp.task('spec', gulp.series('testEnv', test = (done) => {
gulp.src('spec/index.js', {read: false})
.pipe(mocha({require: ['mocha-clean'], reporter: 'spec', exit: true}))
done();
}));
gulp.task('compress', () => {
return gulp.src(['public/js/ready.min.js', 'public/js/pegasus.min.js', '!public/js/highcharts.js', 'public/js/*.js'])
.pipe(concat('all.js'))
.pipe(terser())
.pipe(gulp.dest('public/dist/'));
});
gulp.task('css', () => {
return gulp.src('public/css/*.css')
.pipe(concat('style.css'))
.pipe(minifyCss({compatibility: 'ie8'}))
.pipe(gulp.dest('public/dist/'));
});
gulp.task('minify-ejs-pages', () => {
// Save the pre tag contents
let preLocs = [];
return gulp.src('views/pages/*.ejs')
.pipe(through.obj((chunk, enc, cb) => {
let contents = chunk.contents.toString('utf8');
let preMatches = contents.match(/<pre>((?:.|\n)*?)<\/pre>/g);
if (preMatches) {
preMatches.forEach(match => {
preLocs.push(match);
contents = contents.replace(match, 'PRE_MATCH_' + (preLocs.length-1));
});
chunk.contents = Buffer.from(contents, 'utf8');
}
cb(null, chunk)
}))
.pipe(ejsmin())
.pipe(through.obj((chunk, enc, cb) => {
let contents = chunk.contents.toString('utf8');
let search = new RegExp(/PRE_MATCH_(\d+)/g);
let match = search.exec(contents);
while (match != null) {
contents = contents.replace('PRE_MATCH_' + match[1], preLocs[match[1]]);
match = search.exec(contents);
}
chunk.contents = Buffer.from(contents, 'utf8');
cb(null, chunk)
}))
.pipe(gulp.dest('.viewsMin/pages'))
});
gulp.task('minify-ejs-snippets', () => {
return gulp.src('views/snippets/*.ejs')
.pipe(ejsmin())
.pipe(gulp.dest('.viewsMin/snippets'))
});
gulp.task('build', gulp.series(['compress', 'css', 'minify-ejs-pages', 'minify-ejs-snippets']));
gulp.task('start', gulp.series(['compress', 'css', 'minify-ejs-pages', 'minify-ejs-snippets'], () => {
require('./server');
}));
|
export function selectToken(symbol, address) {
return {
type: "TRANSFER.SELECT_TOKEN",
payload: { symbol, address }
}
}
export function errorSelectToken(message) {
return {
type: "TRANSFER.THOW_ERROR_SELECT_TOKEN",
payload: message
}
}
export function specifyGas(value) {
return {
type: "TRANSFER_SPECIFY_GAS",
payload: value
}
}
export function setRandomTransferSelectedToken(random) {
return {
type: "TRANSFER.SET_RANDOM_SELECTED_TOKEN",
payload: random
}
}
export function specifyGasPrice(value) {
return {
type: "TRANSFER_SPECIFY_GAS_PRICE",
payload: value
}
}
export function toggleAdvance() {
return {
type: "TRANSFER.TOGGLE_ADVANCE",
}
}
export function setDestEthNameAndAddress(destAddress, destEthName) {
return {
type: "TRANSFER.SET_DEST_ETH_NAME_AND_ADDRESS",
payload: { destAddress, destEthName }
}
}
export function clearTransferError() {
return {
type: "TRANSFER.CLEAR_TRANSFER_ERROR"
}
}
export function specifyAmountTransfer(value) {
return {
type: "TRANSFER.TRANSFER_SPECIFY_AMOUNT",
payload: value
}
}
export function estimateGasWhenAmountChange(value) {
return {
type: "TRANSFER.ESTIMATE_GAS_WHEN_AMOUNT_CHANGE",
payload: value
}
}
export function throwErrorDestAddress(key, message) {
return {
type: "TRANSFER.THROW_ERROR_DEST_ADDRESS",
payload: { key, message }
}
}
export function clearErrorDestAddress(key) {
return {
type: "TRANSFER.CLEAR_ERROR_DEST_ADDRESS",
payload: { key }
}
}
export function throwErrorAmount(key, message) {
return {
type: "TRANSFER.THROW_AMOUNT_ERROR",
payload: {key, message}
}
}
export function clearErrorAmount(key) {
return {
type: "TRANSFER.CLEAR_ERROR_AMOUNT",
payload: { key }
}
}
export function finishTransfer() {
return {
type: "TRANSFER.FINISH_TRANSACTION"
}
}
export function doTransactionComplete(tx) {
return {
type: "TRANSFER.TX_BROADCAST_FULFILLED",
payload: {tx},
}
}
export function updateTransferPath(transferPath, currentPathIndex){
return {
type: "TRANSFER.UPDATE_TRANSFER_PATH",
payload: { transferPath, currentPathIndex }
}
}
export function resetTransferPath() {
return {
type: "TRANSFER.RESET_TRANSFER_PATH"
}
}
export function forwardTransferPath() {
return {
type: "TRANSFER.FORWARD_TRANSFER_PATH"
}
}
export function makeNewTransfer() {
return {
type: "TRANSFER.MAKE_NEW_TRANSFER"
}
}
export function updateCurrentBalance(tokenBalance, txHash) {
return {
type: "TRANSFER.UPDATE_CURRENT_BALANCE",
payload: { tokenBalance, txHash }
}
}
export function estimateGasTransfer(ethereum) {
return {
type: "TRANSFER.ESTIMATE_GAS_USED",
payload: {ethereum}
}
}
export function setGasUsed(gas) {
return {
type: "TRANSFER.SET_GAS_USED",
payload: { gas }
}
}
export function setGasUsedSnapshot(gas) {
return {
type: "TRANSFER.SET_GAS_USED_SNAPSHOT",
payload: { gas }
}
}
export function verifyTransfer() {
return {
type: "TRANSFER.VERIFY_TRANSFER",
}
}
export function setSnapshot(data) {
return {
type: "TRANSFER.SET_SNAPSHOT",
payload: data
}
}
export function setGasPriceTransferComplete(safeLowGas, standardGas, fastGas, superFastGas, defaultGas, selectedGas) {
return {
type: "TRANSFER.SET_GAS_PRICE_TRANSFER_COMPLETE",
payload: { safeLowGas, standardGas, defaultGas, fastGas, superFastGas, selectedGas }
}
}
export function setGasPriceSuggest(gasPriceSuggest) {
return {
type: "TRANSFER.SET_GAS_PRICE_SUGGEST",
payload: gasPriceSuggest
}
}
export function seSelectedGas(level) {
return {
type: "TRANSFER.SET_SELECTED_GAS",
payload: { level: level }
}
}
export function openImportAccount() {
return {
type: "TRANSFER.OPEN_IMPORT_ACCOUNT"
}
}
export function closeImportAccountTransfer() {
return {
type: "TRANSFER.CLOSE_IMPORT_ACCOUNT"
}
}
export function toggleBalanceContent() {
return {
type: "TRANSFER.TOGGLE_BALANCE_CONTENT"
}
}
export function toggleAdvanceContent() {
return {
type: "TRANSFER.TOGGLE_ADVANCE_CONTENT"
}
}
export function setIsOpenAdvance() {
return {
type: "TRANSFER.SET_IS_OPEN_ADVANCE",
payload: true
}
}
export function clearIsOpenAdvance() {
return {
type: "TRANSFER.SET_IS_OPEN_ADVANCE",
payload: false
}
}
export function setSelectedGasPrice(gasPrice, gasLevel) {
return {
type: "TRANSFER.SET_SELECTED_GAS_PRICE",
payload: { gasPrice, gasLevel }
}
}
export function setIsSelectTokenBalance(value) {
return {
type: "TRANSFER.SET_IS_SELECT_TOKEN_BALANCE",
payload: value
}
}
|
/**
* @module pipeline
* @copyright 2012 Charles Jolley
*
* Exposes an asset pipeline. Add the generated files you want by passing a
* config. You should include at a minimum:
*
* pipeline = new Pipeline(); // also can pass configs here.
* pipeline.add("path/to/asset.js", {
* type: "javascript", // or "css" to get default configs
* main: "my_package/app/main", // main modules to build from
*
* // additional optional configs
*
* minify: true, // to minify
* autocache: true, // automatically watches dependent files and rebuilds
*
* // plugins - all optional if the type is 'javascript', 'css' or 'less'
* // compilers & preprocessors can be overidden by packages
* // invoked per source file
* compilers: {
* ".js": SomeJavaScriptPlugin,
* ".coffee": SomeCoffeeScriptPlugin
* },
* preprocessors: [SomePreprocessor],
*
* // invoke per source file, extracts dependencies and other info
* analyzer: SomeAnalyzerPlugin,
*
* // generates merged asset. postprocessors run on merged assed before
* // minification
* linker: SomeLinkerPlugin,
* postprocessors: [SomePostprocessor],
*
* // minifies if `minifiy` is true
* minifier: SomeMinifierPlugin,
*
* // run on merged asset after minification (if any). useful to add
* // copyrights
* finalizers: [SomeFinalizerPlugins]
*
* });
*
* Once you have added the asset to the pipeline, you can either use the
* middleware in a connect app:
*
* connect()
* .use(pipeline.middleware())
* .start(3000);
*
* Or you can build the asset out of the pipeline:
*
* pipeline.writeFile("path/to/asset.js", "basedir", function(err) {
* // called when done
* });
*
*/
var PATH = require('path');
var ASYNC = require('async');
var FS = require('fs');
var UTIL = require('util');
var AssetPackager = require('./asset_packager').AssetPackager;
var LoggedEventEmitter = require('./logged_events').LoggedEventEmitter;
var UTILS = require('./utils');
var packagers = require('./packagers');
var middleware = require('./middleware').middleware;
var _extend = UTILS.extend;
var _values = UTILS.values;
var _error = UTILS.makeError;
function Pipeline() {
LoggedEventEmitter.call(this);
this.packagers = {};
this.invalidate = this.invalidate.bind(this); // so we can use as a listener
this._config(arguments);
}
Pipeline.prototype = Object.create(LoggedEventEmitter.prototype);
var CONFIG_KEYS = ['watch', 'paths'];
Pipeline.prototype._config = function(configs) {
var idx, len, config, path;
for(idx=0, len=configs.length; idx<len; idx++) {
config = configs[idx];
for(path in config) {
if (CONFIG_KEYS.indexOf(path)>=0) {
this[path] = config[path];
} else {
if (!config.hasOwnProperty(path)) continue;
this.add(path, config[path]);
}
}
}
return this;
};
/**
* Returns a new middleware instance for use in a connect stack. You can
* pass the same options to this method as you would pass to the connect
* `static()` middleware.
*
* @param {Hash} options Optional hash of options
* @return {Function} connect handler
*/
Pipeline.prototype.middleware = middleware;
/**
* If set to true then pipeline will automatically watch all assets and
* invalidate whenever they change. This will keep it's cache clean when used
* in a server. You can also listen for the `invalidate` event and
* trigger a rebuild if you are using as a build tool.
*
* @type {Boolean}
*/
Pipeline.prototype.watch = false;
/**
* Adds a new generated asset at the named path. Setup with the passed config.
* See the module header for more information on what options can be passed.
*
* @param {String} path relative path into pipeline
* @param {Hash} config config for asset.
* @return {void}
*/
Pipeline.prototype.add = function(path, config) {
var ret, Packager;
if (this.packagers[path]) this.remove(path);
Packager = config.packager;
if ('string' === typeof Packager) {
Packager = packagers[Packager];
if (!Packager) {
throw new Error('Unknown packager ' + config.packager);
}
} else if (!Packager) {
throw new Error('Must define a packager for '+path);
}
config = _extend({
watch: this.watch,
pipeline: this,
path: path
}, config);
ret = new Packager(config);
this.pipeLogging(ret, path);
var invalidate = this.invalidate, self = this;
ret.on('invalidate', function() {
invalidate.apply(self, arguments);
});
this.packagers[path] = ret;
this.invalidate();
return ret;
};
/**
* Removes any asset associated with the named relative path.
*
* @param {String} path path into pipeline
* @return {void}
*/
Pipeline.prototype.remove = function(path) {
var packager = this.packagers[path];
if (packager) {
packager.removeListener('invalidate', this.invalidate);
delete this.packagers[path];
this.invalidate();
}
};
function _selectPackager(pipeline, path, done) {
ASYNC.filter(_values(pipeline.packagers), function(packager, next) {
packager.exists(path, next);
}, function(packagers) {
done(packagers[0]);
});
}
// builds a map of path -> packager
function _mapPaths(pipeline, done) {
ASYNC.reduce(_values(pipeline.packagers), {}, function(memo, packager, next){
packager.findPaths(function(err, paths) {
if (err) return next(err);
paths.forEach(function(path) {
if (!memo[path]) memo[path] = packager;
});
next(null, memo);
});
}, done);
}
/**
* Writes a single asset to the build directory. Invokes callback when done.
*
* @param {String} path Path to write, must match an added asset.
* @param {String} buildir Base directory to build to.
* @param {Function} done Called when done with possible error.
* @return {void}
*/
Pipeline.prototype.writeFile = function(path, buildir, done) {
var self = this;
done = _error(this, done);
_selectPackager(this, path, function(packager) {
if (!packager) return done(new Error('path not found '+path));
packager.build(path, function(err, asset) {
if (err) return done(err);
var dstPath = PATH.resolve(buildir, path);
UTILS.mkdir_p(PATH.dirname(dstPath), function(err) {
if (err) return done(err);
if (asset.bodyPath) {
UTILS.cp_r(asset.bodyPath, dstPath, self, done);
} else if (asset.body) {
var encoding = asset.encoding || 'utf8';
FS.writeFile(dstPath, asset.body, encoding, function(err) {
if (!err) self.info('wrote', dstPath);
done(err);
});
} else {
return done(new Error(path+' asset does not contain body'));
}
});
});
});
};
/**
* Writes all defined assets to the named build directory. Invokes the callback
* when done.
*
* @param {String} buildir Directory to build to
* @param {Function} done Called when done with possible error
* @return {void}
*/
Pipeline.prototype.writeAll = function(buildir, done) {
var self = this;
self.findPaths(function(err, paths) {
if (err) return done(err);
ASYNC.forEach(paths, function(path, next) {
self.writeFile(path, buildir, next);
}, done);
});
};
/**
* Builds a single asset. The callback will be invoked with an asset object.
* The asset contains either a `body` property or a `bodyPath` that can
* be used to return the asset contents.
*
* @param {String} path Path within pipeline
* @param {Function} done Calling to invoke when asset is ready.
* @return {void}
*/
Pipeline.prototype.build = function(path, done) {
done = _error(this, done);
this._canInvalidate = true;
_selectPackager(this, path, function(packager) {
if (!packager) {
done(new Error('path not found '+path));
} else {
packager.build(path, done);
}
});
};
/**
* Invokes the done callback with `true` if the pipeline knows how to handle
* the path. You will often use this when implementing middleware in a server.
*
* @param {String} path path to evaluate
* @param {Function} callback Invoked in response.
* @return {void}
*/
Pipeline.prototype.exists = function(path, callback) {
_selectPackager(this, path, function(packager) {
callback(!!packager);
});
};
/**
* Discovers all the valid paths handled by this pipeline and returns them in
* the done callback. This can involve crawling the disk for asset
* directories.
*
* @param {Function} done Callback
* @return {void}
*/
Pipeline.prototype.findPaths = function(done) {
this._canInvalidate = true;
_mapPaths(this, function(err, packagers) {
done(err, !err && packagers ? Object.keys(packagers) : null);
});
};
Pipeline.prototype.invalidate = function() {
if (this._canInvalidate) {
this._canInvalidate = false;
this.emit('invalidate');
}
};
exports.Pipeline = Pipeline;
|
/**
* app.js
*
* This is the entry file for the application, only setup and boilerplate
* code.
*/
import 'babel-polyfill';
// TODO constrain eslint import/no-unresolved rule to this block
// Load the manifest.json file and the .htaccess file
import '!file?name=[name].[ext]!./manifest.json'; // eslint-disable-line import/no-unresolved
import 'file?name=[name].[ext]!./.htaccess'; // eslint-disable-line import/no-unresolved
// Import all the third party stuff
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { applyRouterMiddleware, Router, browserHistory } from 'react-router';
import { syncHistoryWithStore } from 'react-router-redux';
import useScroll from 'react-router-scroll';
import configureStore from './store';
// Import the CSS reset, which HtmlWebpackPlugin transfers to the build folder
import 'sanitize.css/sanitize.css';
// Create redux store with history
// this uses the singleton browserHistory provided by react-router
// Optionally, this could be changed to leverage a created history
// e.g. `const browserHistory = useRouterHistory(createBrowserHistory)();`
const initialState = {};
const store = configureStore(initialState, browserHistory);
// Sync history and store, as the react-router-redux reducer
// is under the non-default key ("routing"), selectLocationState
// must be provided for resolving how to retrieve the "route" in the state
import { selectLocationState } from 'containers/App/selectors';
const history = syncHistoryWithStore(browserHistory, store, {
selectLocationState: selectLocationState(),
});
// Set up the router, wrapping all Routes in the App component
import App from 'containers/App';
import createRoutes from './routes';
const rootRoute = {
component: App,
childRoutes: createRoutes(store),
};
ReactDOM.render(
<Provider store={store}>
<Router
history={history}
routes={rootRoute}
render={
// Scroll to top when going to a new page, imitating default browser
// behaviour
applyRouterMiddleware(useScroll())
}
/>
</Provider>,
document.getElementById('app')
);
// Install ServiceWorker and AppCache in the end since
// it's not most important operation and if main code fails,
// we do not want it installed
import { install } from 'offline-plugin/runtime';
install();
// Setup localforage
import localforage from 'localforage';
localforage.config({
driver: localforage.LOCALSTORAGE, // Force WebSQL; same as using setDriver()
name: 'rise2016-app',
version: 1.0,
size: 4980736, // Size of database, in bytes. WebSQL-only for now.
storeName: 'rise2016_app', // Should be alphanumeric, with underscores.
description: 'RISE 2016 App',
});
|
'use strict';
var observatory = require('../lib/observatory');
var faker = require('faker');
var q = require('q');
function delay(ms) {
var deferred = q.defer();
setTimeout(deferred.resolve, faker.random.number(ms || 2000));
return deferred.promise;
}
function createRandomTask() {
var task = observatory.add('These lines will need to wrap abcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqurstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
var percent = 0;
function download () {
percent++;
task.status(percent + '%');
if (percent === 100) {
return task.done();
}
return delay(100).then(download);
}
download();
}
function randomlyAddMore() {
createRandomTask();
delay()
.then(function(){
createRandomTask();
});
}
console.log(' ⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽⎽');
console.log(' Running Really long lines ');
console.log(' ⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺');
randomlyAddMore();
|
// rewrite by efront authors
/*!
Copyright (C) 2010-2013 Raymond Hill: https://github.com/gorhill/Javascript-Voronoi
MIT License: See https://github.com/gorhill/Javascript-Voronoi/LICENSE.md
*/
/*
Author: Raymond Hill (rhill@raymondhill.net)
Contributor: Jesse Morgan (morgajel@gmail.com)
File: rhill-voronoi-core.js
Version: 0.98
Date: January 21, 2013
Description: This is my personal Javascript implementation of
Steven Fortune's algorithm to compute Voronoi diagrams.
License: See https://github.com/gorhill/Javascript-Voronoi/LICENSE.md
Credits: See https://github.com/gorhill/Javascript-Voronoi/CREDITS.md
History: See https://github.com/gorhill/Javascript-Voronoi/CHANGELOG.md
## Usage:
var sites = [{x:300,y:300}, {x:100,y:100}, {x:200,y:500}, {x:250,y:450}, {x:600,y:150}];
// xl, xr means x left, x right
// yt, yb means y top, y bottom
var bbox = {xl:0, xr:800, yt:0, yb:600};
var voronoi = new Voronoi();
// pass an object which exhibits xl, xr, yt, yb properties. The bounding
// box will be used to connect unbound edges, and to close open cells
result = voronoi.compute(sites, bbox);
// render, further analyze, etc.
Return value:
An object with the following properties:
result.vertices = an array of unordered, unique Voronoi.Vertex objects making
up the Voronoi diagram.
result.edges = an array of unordered, unique Voronoi.Edge objects making up
the Voronoi diagram.
result.cells = an array of Voronoi.Cell object making up the Voronoi diagram.
A Cell object might have an empty array of halfedges, meaning no Voronoi
cell could be computed for a particular cell.
result.execTime = the time it took to compute the Voronoi diagram, in
milliseconds.
Voronoi.Vertex object:
x: The x position of the vertex.
y: The y position of the vertex.
Voronoi.Edge object:
lSite: the Voronoi site object at the left of this Voronoi.Edge object.
rSite: the Voronoi site object at the right of this Voronoi.Edge object (can
be null).
va: an object with an 'x' and a 'y' property defining the start point
(relative to the Voronoi site on the left) of this Voronoi.Edge object.
vb: an object with an 'x' and a 'y' property defining the end point
(relative to Voronoi site on the left) of this Voronoi.Edge object.
For edges which are used to close open cells (using the supplied bounding
box), the rSite property will be null.
Voronoi.Cell object:
site: the Voronoi site object associated with the Voronoi cell.
halfedges: an array of Voronoi.Halfedge objects, ordered counterclockwise,
defining the polygon for this Voronoi cell.
Voronoi.Halfedge object:
site: the Voronoi site object owning this Voronoi.Halfedge object.
edge: a reference to the unique Voronoi.Edge object underlying this
Voronoi.Halfedge object.
getStartpoint(): a method returning an object with an 'x' and a 'y' property
for the start point of this halfedge. Keep in mind halfedges are always
countercockwise.
getEndpoint(): a method returning an object with an 'x' and a 'y' property
for the end point of this halfedge. Keep in mind halfedges are always
countercockwise.
TODO: Identify opportunities for performance improvement.
TODO: Let the user close the Voronoi cells, do not do it automatically. Not only let
him close the cells, but also allow him to close more than once using a different
bounding box for the same Voronoi diagram.
*/
/*global Math */
// ---------------------------------------------------------------------------
function Voronoi() {
this.vertices = null;
this.edges = null;
this.cells = null;
this.toRecycle = null;
this.beachsectionJunkyard = [];
this.circleEventJunkyard = [];
this.vertexJunkyard = [];
this.edgeJunkyard = [];
this.cellJunkyard = [];
}
Voronoi.ε = 1e-9;
Voronoi.invε = 1.0 / Voronoi.ε;
// ---------------------------------------------------------------------------
// Red-Black tree code (based on C version of "rbtree" by Franck Bui-Huu
// https://github.com/fbuihuu/libtree/blob/master/rb.c
class RBTree {
root = null;
rbInsertSuccessor(node, successor) {
var parent;
if (node) {
// >>> rhill 2011-05-27: Performance: cache previous/next nodes
successor.rbPrevious = node;
successor.rbNext = node.rbNext;
if (node.rbNext) {
node.rbNext.rbPrevious = successor;
}
node.rbNext = successor;
// <<<
if (node.rbRight) {
// in-place expansion of node.rbRight.getFirst();
node = node.rbRight;
while (node.rbLeft) { node = node.rbLeft; }
node.rbLeft = successor;
}
else {
node.rbRight = successor;
}
parent = node;
}
// rhill 2011-06-07: if node is null, successor must be inserted
// to the left-most part of the tree
else if (this.root) {
node = this.getFirst(this.root);
// >>> Performance: cache previous/next nodes
successor.rbPrevious = null;
successor.rbNext = node;
node.rbPrevious = successor;
// <<<
node.rbLeft = successor;
parent = node;
}
else {
// >>> Performance: cache previous/next nodes
successor.rbPrevious = successor.rbNext = null;
// <<<
this.root = successor;
parent = null;
}
successor.rbLeft = successor.rbRight = null;
successor.rbParent = parent;
successor.rbRed = true;
// Fixup the modified tree by recoloring nodes and performing
// rotations (2 at most) hence the red-black tree properties are
// preserved.
var grandpa, uncle;
node = successor;
while (parent && parent.rbRed) {
grandpa = parent.rbParent;
if (parent === grandpa.rbLeft) {
uncle = grandpa.rbRight;
if (uncle && uncle.rbRed) {
parent.rbRed = uncle.rbRed = false;
grandpa.rbRed = true;
node = grandpa;
}
else {
if (node === parent.rbRight) {
this.rbRotateLeft(parent);
node = parent;
parent = node.rbParent;
}
parent.rbRed = false;
grandpa.rbRed = true;
this.rbRotateRight(grandpa);
}
}
else {
uncle = grandpa.rbLeft;
if (uncle && uncle.rbRed) {
parent.rbRed = uncle.rbRed = false;
grandpa.rbRed = true;
node = grandpa;
}
else {
if (node === parent.rbLeft) {
this.rbRotateRight(parent);
node = parent;
parent = node.rbParent;
}
parent.rbRed = false;
grandpa.rbRed = true;
this.rbRotateLeft(grandpa);
}
}
parent = node.rbParent;
}
this.root.rbRed = false;
}
rbRemoveNode(node) {
// >>> rhill 2011-05-27: Performance: cache previous/next nodes
if (node.rbNext) {
node.rbNext.rbPrevious = node.rbPrevious;
}
if (node.rbPrevious) {
node.rbPrevious.rbNext = node.rbNext;
}
node.rbNext = node.rbPrevious = null;
// <<<
var parent = node.rbParent,
left = node.rbLeft,
right = node.rbRight,
next;
if (!left) {
next = right;
}
else if (!right) {
next = left;
}
else {
next = this.getFirst(right);
}
if (parent) {
if (parent.rbLeft === node) {
parent.rbLeft = next;
}
else {
parent.rbRight = next;
}
}
else {
this.root = next;
}
// enforce red-black rules
var isRed;
if (left && right) {
isRed = next.rbRed;
next.rbRed = node.rbRed;
next.rbLeft = left;
left.rbParent = next;
if (next !== right) {
parent = next.rbParent;
next.rbParent = node.rbParent;
node = next.rbRight;
parent.rbLeft = node;
next.rbRight = right;
right.rbParent = next;
}
else {
next.rbParent = parent;
parent = next;
node = next.rbRight;
}
}
else {
isRed = node.rbRed;
node = next;
}
// 'node' is now the sole successor's child and 'parent' its
// new parent (since the successor can have been moved)
if (node) {
node.rbParent = parent;
}
// the 'easy' cases
if (isRed) { return; }
if (node && node.rbRed) {
node.rbRed = false;
return;
}
// the other cases
var sibling;
do {
if (node === this.root) {
break;
}
if (node === parent.rbLeft) {
sibling = parent.rbRight;
if (sibling.rbRed) {
sibling.rbRed = false;
parent.rbRed = true;
this.rbRotateLeft(parent);
sibling = parent.rbRight;
}
if ((sibling.rbLeft && sibling.rbLeft.rbRed) || (sibling.rbRight && sibling.rbRight.rbRed)) {
if (!sibling.rbRight || !sibling.rbRight.rbRed) {
sibling.rbLeft.rbRed = false;
sibling.rbRed = true;
this.rbRotateRight(sibling);
sibling = parent.rbRight;
}
sibling.rbRed = parent.rbRed;
parent.rbRed = sibling.rbRight.rbRed = false;
this.rbRotateLeft(parent);
node = this.root;
break;
}
}
else {
sibling = parent.rbLeft;
if (sibling.rbRed) {
sibling.rbRed = false;
parent.rbRed = true;
this.rbRotateRight(parent);
sibling = parent.rbLeft;
}
if ((sibling.rbLeft && sibling.rbLeft.rbRed) || (sibling.rbRight && sibling.rbRight.rbRed)) {
if (!sibling.rbLeft || !sibling.rbLeft.rbRed) {
sibling.rbRight.rbRed = false;
sibling.rbRed = true;
this.rbRotateLeft(sibling);
sibling = parent.rbLeft;
}
sibling.rbRed = parent.rbRed;
parent.rbRed = sibling.rbLeft.rbRed = false;
this.rbRotateRight(parent);
node = this.root;
break;
}
}
sibling.rbRed = true;
node = parent;
parent = parent.rbParent;
} while (!node.rbRed);
if (node) { node.rbRed = false; }
}
rbRotateLeft(node) {
var p = node,
q = node.rbRight, // can't be null
parent = p.rbParent;
if (parent) {
if (parent.rbLeft === p) {
parent.rbLeft = q;
}
else {
parent.rbRight = q;
}
}
else {
this.root = q;
}
q.rbParent = parent;
p.rbParent = q;
p.rbRight = q.rbLeft;
if (p.rbRight) {
p.rbRight.rbParent = p;
}
q.rbLeft = p;
}
rbRotateRight(node) {
var p = node,
q = node.rbLeft, // can't be null
parent = p.rbParent;
if (parent) {
if (parent.rbLeft === p) {
parent.rbLeft = q;
}
else {
parent.rbRight = q;
}
}
else {
this.root = q;
}
q.rbParent = parent;
p.rbParent = q;
p.rbLeft = q.rbRight;
if (p.rbLeft) {
p.rbLeft.rbParent = p;
}
q.rbRight = p;
}
getFirst(node) {
while (node.rbLeft) {
node = node.rbLeft;
}
return node;
}
getLast(node) {
while (node.rbRight) {
node = node.rbRight;
}
return node;
}
}
// ---------------------------------------------------------------------------
// Diagram methods
class Diagram {
constructor(site) {
this.site = site;
}
}
// ---------------------------------------------------------------------------
// Cell methods
class Cell {
constructor(site) {
this.site = site;
this.halfedges = [];
this.closeMe = false;
}
init(site) {
this.site = site;
this.halfedges = [];
this.closeMe = false;
return this;
}
prepareHalfedges() {
var halfedges = this.halfedges,
iHalfedge = halfedges.length,
edge;
// get rid of unused halfedges
// rhill 2011-05-27: Keep it simple, no point here in trying
// to be fancy: dangling edges are a typically a minority.
while (iHalfedge--) {
edge = halfedges[iHalfedge].edge;
if (!edge.vb || !edge.va) {
halfedges.splice(iHalfedge, 1);
}
}
// rhill 2011-05-26: I tried to use a binary search at insertion
// time to keep the array sorted on-the-fly (in Cell.addHalfedge()).
// There was no real benefits in doing so, performance on
// Firefox 3.6 was improved marginally, while performance on
// Opera 11 was penalized marginally.
halfedges.sort(function (a, b) { return b.angle - a.angle; });
return halfedges.length;
}
// Return a list of the neighbor Ids
getNeighborIds() {
var neighbors = [],
iHalfedge = this.halfedges.length,
edge;
while (iHalfedge--) {
edge = this.halfedges[iHalfedge].edge;
if (edge.lSite !== null && edge.lSite.voronoiId != this.site.voronoiId) {
neighbors.push(edge.lSite.voronoiId);
}
else if (edge.rSite !== null && edge.rSite.voronoiId != this.site.voronoiId) {
neighbors.push(edge.rSite.voronoiId);
}
}
return neighbors;
}
// Compute bounding box
getBbox() {
var halfedges = this.halfedges,
iHalfedge = halfedges.length,
xmin = Infinity,
ymin = Infinity,
xmax = -Infinity,
ymax = -Infinity,
v, vx, vy;
while (iHalfedge--) {
v = halfedges[iHalfedge].getStartpoint();
vx = v.x;
vy = v.y;
if (vx < xmin) { xmin = vx; }
if (vy < ymin) { ymin = vy; }
if (vx > xmax) { xmax = vx; }
if (vy > ymax) { ymax = vy; }
// we dont need to take into account end point,
// since each end point matches a start point
}
return {
x: xmin,
y: ymin,
width: xmax - xmin,
height: ymax - ymin
};
}
// Return whether a point is inside, on, or outside the cell:
// -1: point is outside the perimeter of the cell
// 0: point is on the perimeter of the cell
// 1: point is inside the perimeter of the cell
//
pointIntersection(x, y) {
// Check if point in polygon. Since all polygons of a Voronoi
// diagram are convex, then:
// http://paulbourke.net/geometry/polygonmesh/
// Solution 3 (2D):
// "If the polygon is convex then one can consider the polygon
// "as a 'path' from the first vertex. A point is on the interior
// "of this polygons if it is always on the same side of all the
// "line segments making up the path. ...
// "(y - y0) (x1 - x0) - (x - x0) (y1 - y0)
// "if it is less than 0 then P is to the right of the line segment,
// "if greater than 0 it is to the left, if equal to 0 then it lies
// "on the line segment"
var halfedges = this.halfedges,
iHalfedge = halfedges.length,
halfedge,
p0, p1, r;
while (iHalfedge--) {
halfedge = halfedges[iHalfedge];
p0 = halfedge.getStartpoint();
p1 = halfedge.getEndpoint();
r = (y - p0.y) * (p1.x - p0.x) - (x - p0.x) * (p1.y - p0.y);
if (!r) {
return 0;
}
if (r > 0) {
return -1;
}
}
return 1;
}
}
// ---------------------------------------------------------------------------
// Edge methods
//
class Vertex {
constructor(x, y) {
this.x = x;
this.y = y;
}
}
class Edge {
constructor(lSite, rSite) {
this.lSite = lSite;
this.rSite = rSite;
this.va = this.vb = null;
}
}
class Halfedge {
constructor(edge, lSite, rSite) {
this.site = lSite;
this.edge = edge;
// 'angle' is a value to be used for properly sorting the
// halfsegments counterclockwise. By convention, we will
// use the angle of the line defined by the 'site to the left'
// to the 'site to the right'.
// However, border edges have no 'site to the right': thus we
// use the angle of line perpendicular to the halfsegment (the
// edge should have both end points defined in such case.)
if (rSite) {
this.angle = Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x);
}
else {
var va = edge.va,
vb = edge.vb;
// rhill 2011-05-31: used to call getStartpoint()/getEndpoint(),
// but for performance purpose, these are expanded in place here.
this.angle = edge.lSite === lSite ?
Math.atan2(vb.x - va.x, va.y - vb.y) :
Math.atan2(va.x - vb.x, vb.y - va.y);
}
}
getStartpoint() {
return this.edge.lSite === this.site ? this.edge.va : this.edge.vb;
}
getEndpoint() {
return this.edge.lSite === this.site ? this.edge.vb : this.edge.va;
}
}
// ---------------------------------------------------------------------------
// Beachline methods
// rhill 2011-06-07: For some reasons, performance suffers significantly
// when instanciating a literal object instead of an empty ctor
class Beachsection {
};
// ---------------------------------------------------------------------------
// Circle event methods
// rhill 2011-06-07: For some reasons, performance suffers significantly
// when instanciating a literal object instead of an empty ctor
class CircleEvent {
constructor() {
// rhill 2013-10-12: it helps to state exactly what we are at ctor time.
this.arc = null;
this.rbLeft = null;
this.rbNext = null;
this.rbParent = null;
this.rbPrevious = null;
this.rbRed = false;
this.rbRight = null;
this.site = null;
this.x = this.y = this.ycenter = 0;
}
};
Voronoi.prototype = {
reset() {
if (!this.beachline) {
this.beachline = new this.RBTree();
}
// Move leftover beachsections to the beachsection junkyard.
if (this.beachline.root) {
var beachsection = this.beachline.getFirst(this.beachline.root);
while (beachsection) {
this.beachsectionJunkyard.push(beachsection); // mark for reuse
beachsection = beachsection.rbNext;
}
}
this.beachline.root = null;
if (!this.circleEvents) {
this.circleEvents = new this.RBTree();
}
this.circleEvents.root = this.firstCircleEvent = null;
this.vertices = [];
this.edges = [];
this.cells = [];
},
equalWithEpsilon(a, b) { return this.abs(a - b) < 1e-9; },
greaterThanWithEpsilon(a, b) { return a - b > 1e-9; },
greaterThanOrEqualWithEpsilon(a, b) { return b - a < 1e-9; },
lessThanWithEpsilon(a, b) { return b - a > 1e-9; },
lessThanOrEqualWithEpsilon(a, b) { return a - b < 1e-9; },
RBTree: RBTree,
Diagram: Diagram,
Cell: Cell,
Vertex: Vertex,
Edge: Edge,
Halfedge: Halfedge,
Beachsection: Beachsection,
CircleEvent: CircleEvent,
sqrt: Math.sqrt,
abs: Math.abs,
ε: Voronoi.ε,
invε: Voronoi.invε,
createCell(site) {
var cell = this.cellJunkyard.pop();
if (cell) {
return cell.init(site);
}
return new this.Cell(site);
},
createHalfedge(edge, lSite, rSite) {
return new this.Halfedge(edge, lSite, rSite);
},
// this create and add a vertex to the internal collection
createVertex(x, y) {
var v = this.vertexJunkyard.pop();
if (!v) {
v = new this.Vertex(x, y);
}
else {
v.x = x;
v.y = y;
}
this.vertices.push(v);
return v;
},
// this create and add an edge to internal collection, and also create
// two halfedges which are added to each site's counterclockwise array
// of halfedges.
createEdge(lSite, rSite, va, vb) {
var edge = this.edgeJunkyard.pop();
if (!edge) {
edge = new this.Edge(lSite, rSite);
}
else {
edge.lSite = lSite;
edge.rSite = rSite;
edge.va = edge.vb = null;
}
this.edges.push(edge);
if (va) {
this.setEdgeStartpoint(edge, lSite, rSite, va);
}
if (vb) {
this.setEdgeEndpoint(edge, lSite, rSite, vb);
}
this.cells[lSite.voronoiId].halfedges.push(this.createHalfedge(edge, lSite, rSite));
this.cells[rSite.voronoiId].halfedges.push(this.createHalfedge(edge, rSite, lSite));
return edge;
},
createBorderEdge(lSite, va, vb) {
var edge = this.edgeJunkyard.pop();
if (!edge) {
edge = new this.Edge(lSite, null);
}
else {
edge.lSite = lSite;
edge.rSite = null;
}
edge.va = va;
edge.vb = vb;
this.edges.push(edge);
return edge;
},
setEdgeStartpoint(edge, lSite, rSite, vertex) {
if (!edge.va && !edge.vb) {
edge.va = vertex;
edge.lSite = lSite;
edge.rSite = rSite;
}
else if (edge.lSite === rSite) {
edge.vb = vertex;
}
else {
edge.va = vertex;
}
},
setEdgeEndpoint(edge, lSite, rSite, vertex) {
this.setEdgeStartpoint(edge, rSite, lSite, vertex);
},
// rhill 2011-06-02: A lot of Beachsection instanciations
// occur during the computation of the Voronoi diagram,
// somewhere between the number of sites and twice the
// number of sites, while the number of Beachsections on the
// beachline at any given time is comparatively low. For this
// reason, we reuse already created Beachsections, in order
// to avoid new memory allocation. This resulted in a measurable
// performance gain.
createBeachsection(site) {
var beachsection = this.beachsectionJunkyard.pop();
if (!beachsection) {
beachsection = new this.Beachsection();
}
beachsection.site = site;
return beachsection;
},
// calculate the left break point of a particular beach section,
// given a particular sweep line
leftBreakPoint(arc, directrix) {
// http://en.wikipedia.org/wiki/Parabola
// http://en.wikipedia.org/wiki/Quadratic_equation
// h1 = x1,
// k1 = (y1+directrix)/2,
// h2 = x2,
// k2 = (y2+directrix)/2,
// p1 = k1-directrix,
// a1 = 1/(4*p1),
// b1 = -h1/(2*p1),
// c1 = h1*h1/(4*p1)+k1,
// p2 = k2-directrix,
// a2 = 1/(4*p2),
// b2 = -h2/(2*p2),
// c2 = h2*h2/(4*p2)+k2,
// x = (-(b2-b1) + Math.sqrt((b2-b1)*(b2-b1) - 4*(a2-a1)*(c2-c1))) / (2*(a2-a1))
// When x1 become the x-origin:
// h1 = 0,
// k1 = (y1+directrix)/2,
// h2 = x2-x1,
// k2 = (y2+directrix)/2,
// p1 = k1-directrix,
// a1 = 1/(4*p1),
// b1 = 0,
// c1 = k1,
// p2 = k2-directrix,
// a2 = 1/(4*p2),
// b2 = -h2/(2*p2),
// c2 = h2*h2/(4*p2)+k2,
// x = (-b2 + Math.sqrt(b2*b2 - 4*(a2-a1)*(c2-k1))) / (2*(a2-a1)) + x1
// change code below at your own risk: care has been taken to
// reduce errors due to computers' finite arithmetic precision.
// Maybe can still be improved, will see if any more of this
// kind of errors pop up again.
var site = arc.site,
rfocx = site.x,
rfocy = site.y,
pby2 = rfocy - directrix;
// parabola in degenerate case where focus is on directrix
if (!pby2) {
return rfocx;
}
var lArc = arc.rbPrevious;
if (!lArc) {
return -Infinity;
}
site = lArc.site;
var lfocx = site.x,
lfocy = site.y,
plby2 = lfocy - directrix;
// parabola in degenerate case where focus is on directrix
if (!plby2) {
return lfocx;
}
var hl = lfocx - rfocx,
aby2 = 1 / pby2 - 1 / plby2,
b = hl / plby2;
if (aby2) {
return (-b + this.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
}
// both parabolas have same distance to directrix, thus break point is midway
return (rfocx + lfocx) / 2;
},
// calculate the right break point of a particular beach section,
// given a particular directrix
rightBreakPoint(arc, directrix) {
var rArc = arc.rbNext;
if (rArc) {
return this.leftBreakPoint(rArc, directrix);
}
var site = arc.site;
return site.y === directrix ? site.x : Infinity;
},
detachBeachsection(beachsection) {
this.detachCircleEvent(beachsection); // detach potentially attached circle event
this.beachline.rbRemoveNode(beachsection); // remove from RB-tree
this.beachsectionJunkyard.push(beachsection); // mark for reuse
},
removeBeachsection(beachsection) {
var circle = beachsection.circleEvent,
x = circle.x,
y = circle.ycenter,
vertex = this.createVertex(x, y),
previous = beachsection.rbPrevious,
next = beachsection.rbNext,
disappearingTransitions = [beachsection],
abs_fn = Math.abs;
// remove collapsed beachsection from beachline
this.detachBeachsection(beachsection);
// there could be more than one empty arc at the deletion point, this
// happens when more than two edges are linked by the same vertex,
// so we will collect all those edges by looking up both sides of
// the deletion point.
// by the way, there is *always* a predecessor/successor to any collapsed
// beach section, it's just impossible to have a collapsing first/last
// beach sections on the beachline, since they obviously are unconstrained
// on their left/right side.
// look left
var lArc = previous;
while (lArc.circleEvent && abs_fn(x - lArc.circleEvent.x) < 1e-9 && abs_fn(y - lArc.circleEvent.ycenter) < 1e-9) {
previous = lArc.rbPrevious;
disappearingTransitions.unshift(lArc);
this.detachBeachsection(lArc); // mark for reuse
lArc = previous;
}
// even though it is not disappearing, I will also add the beach section
// immediately to the left of the left-most collapsed beach section, for
// convenience, since we need to refer to it later as this beach section
// is the 'left' site of an edge for which a start point is set.
disappearingTransitions.unshift(lArc);
this.detachCircleEvent(lArc);
// look right
var rArc = next;
while (rArc.circleEvent && abs_fn(x - rArc.circleEvent.x) < 1e-9 && abs_fn(y - rArc.circleEvent.ycenter) < 1e-9) {
next = rArc.rbNext;
disappearingTransitions.push(rArc);
this.detachBeachsection(rArc); // mark for reuse
rArc = next;
}
// we also have to add the beach section immediately to the right of the
// right-most collapsed beach section, since there is also a disappearing
// transition representing an edge's start point on its left.
disappearingTransitions.push(rArc);
this.detachCircleEvent(rArc);
// walk through all the disappearing transitions between beach sections and
// set the start point of their (implied) edge.
var nArcs = disappearingTransitions.length,
iArc;
for (iArc = 1; iArc < nArcs; iArc++) {
rArc = disappearingTransitions[iArc];
lArc = disappearingTransitions[iArc - 1];
this.setEdgeStartpoint(rArc.edge, lArc.site, rArc.site, vertex);
}
// create a new edge as we have now a new transition between
// two beach sections which were previously not adjacent.
// since this edge appears as a new vertex is defined, the vertex
// actually define an end point of the edge (relative to the site
// on the left)
lArc = disappearingTransitions[0];
rArc = disappearingTransitions[nArcs - 1];
rArc.edge = this.createEdge(lArc.site, rArc.site, undefined, vertex);
// create circle events if any for beach sections left in the beachline
// adjacent to collapsed sections
this.attachCircleEvent(lArc);
this.attachCircleEvent(rArc);
},
addBeachsection(site) {
var x = site.x,
directrix = site.y;
// find the left and right beach sections which will surround the newly
// created beach section.
// rhill 2011-06-01: This loop is one of the most often executed,
// hence we expand in-place the comparison-against-epsilon calls.
var lArc, rArc,
dxl, dxr,
node = this.beachline.root;
while (node) {
dxl = this.leftBreakPoint(node, directrix) - x;
// x lessThanWithEpsilon xl => falls somewhere before the left edge of the beachsection
if (dxl > 1e-9) {
// this case should never happen
// if (!node.rbLeft) {
// rArc = node.rbLeft;
// break;
// }
node = node.rbLeft;
}
else {
dxr = x - this.rightBreakPoint(node, directrix);
// x greaterThanWithEpsilon xr => falls somewhere after the right edge of the beachsection
if (dxr > 1e-9) {
if (!node.rbRight) {
lArc = node;
break;
}
node = node.rbRight;
}
else {
// x equalWithEpsilon xl => falls exactly on the left edge of the beachsection
if (dxl > -1e-9) {
lArc = node.rbPrevious;
rArc = node;
}
// x equalWithEpsilon xr => falls exactly on the right edge of the beachsection
else if (dxr > -1e-9) {
lArc = node;
rArc = node.rbNext;
}
// falls exactly somewhere in the middle of the beachsection
else {
lArc = rArc = node;
}
break;
}
}
}
// at this point, keep in mind that lArc and/or rArc could be
// undefined or null.
// create a new beach section object for the site and add it to RB-tree
var newArc = this.createBeachsection(site);
this.beachline.rbInsertSuccessor(lArc, newArc);
// cases:
//
// [null,null]
// least likely case: new beach section is the first beach section on the
// beachline.
// This case means:
// no new transition appears
// no collapsing beach section
// new beachsection become root of the RB-tree
if (!lArc && !rArc) {
return;
}
// [lArc,rArc] where lArc == rArc
// most likely case: new beach section split an existing beach
// section.
// This case means:
// one new transition appears
// the left and right beach section might be collapsing as a result
// two new nodes added to the RB-tree
if (lArc === rArc) {
// invalidate circle event of split beach section
this.detachCircleEvent(lArc);
// split the beach section into two separate beach sections
rArc = this.createBeachsection(lArc.site);
this.beachline.rbInsertSuccessor(newArc, rArc);
// since we have a new transition between two beach sections,
// a new edge is born
newArc.edge = rArc.edge = this.createEdge(lArc.site, newArc.site);
// check whether the left and right beach sections are collapsing
// and if so create circle events, to be notified when the point of
// collapse is reached.
this.attachCircleEvent(lArc);
this.attachCircleEvent(rArc);
return;
}
// [lArc,null]
// even less likely case: new beach section is the *last* beach section
// on the beachline -- this can happen *only* if *all* the previous beach
// sections currently on the beachline share the same y value as
// the new beach section.
// This case means:
// one new transition appears
// no collapsing beach section as a result
// new beach section become right-most node of the RB-tree
if (lArc && !rArc) {
newArc.edge = this.createEdge(lArc.site, newArc.site);
return;
}
// [null,rArc]
// impossible case: because sites are strictly processed from top to bottom,
// and left to right, which guarantees that there will always be a beach section
// on the left -- except of course when there are no beach section at all on
// the beach line, which case was handled above.
// rhill 2011-06-02: No point testing in non-debug version
//if (!lArc && rArc) {
// throw "Voronoi.addBeachsection(): What is this I don't even";
// }
// [lArc,rArc] where lArc != rArc
// somewhat less likely case: new beach section falls *exactly* in between two
// existing beach sections
// This case means:
// one transition disappears
// two new transitions appear
// the left and right beach section might be collapsing as a result
// only one new node added to the RB-tree
if (lArc !== rArc) {
// invalidate circle events of left and right sites
this.detachCircleEvent(lArc);
this.detachCircleEvent(rArc);
// an existing transition disappears, meaning a vertex is defined at
// the disappearance point.
// since the disappearance is caused by the new beachsection, the
// vertex is at the center of the circumscribed circle of the left,
// new and right beachsections.
// http://mathforum.org/library/drmath/view/55002.html
// Except that I bring the origin at A to simplify
// calculation
var lSite = lArc.site,
ax = lSite.x,
ay = lSite.y,
bx = site.x - ax,
by = site.y - ay,
rSite = rArc.site,
cx = rSite.x - ax,
cy = rSite.y - ay,
d = 2 * (bx * cy - by * cx),
hb = bx * bx + by * by,
hc = cx * cx + cy * cy,
vertex = this.createVertex((cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay);
// one transition disappear
this.setEdgeStartpoint(rArc.edge, lSite, rSite, vertex);
// two new transitions appear at the new vertex location
newArc.edge = this.createEdge(lSite, site, undefined, vertex);
rArc.edge = this.createEdge(site, rSite, undefined, vertex);
// check whether the left and right beach sections are collapsing
// and if so create circle events, to handle the point of collapse.
this.attachCircleEvent(lArc);
this.attachCircleEvent(rArc);
return;
}
},
attachCircleEvent(arc) {
var lArc = arc.rbPrevious,
rArc = arc.rbNext;
if (!lArc || !rArc) { return; } // does that ever happen?
var lSite = lArc.site,
cSite = arc.site,
rSite = rArc.site;
// If site of left beachsection is same as site of
// right beachsection, there can't be convergence
if (lSite === rSite) { return; }
// Find the circumscribed circle for the three sites associated
// with the beachsection triplet.
// rhill 2011-05-26: It is more efficient to calculate in-place
// rather than getting the resulting circumscribed circle from an
// object returned by calling Voronoi.circumcircle()
// http://mathforum.org/library/drmath/view/55002.html
// Except that I bring the origin at cSite to simplify calculations.
// The bottom-most part of the circumcircle is our Fortune 'circle
// event', and its center is a vertex potentially part of the final
// Voronoi diagram.
var bx = cSite.x,
by = cSite.y,
ax = lSite.x - bx,
ay = lSite.y - by,
cx = rSite.x - bx,
cy = rSite.y - by;
// If points l->c->r are clockwise, then center beach section does not
// collapse, hence it can't end up as a vertex (we reuse 'd' here, which
// sign is reverse of the orientation, hence we reverse the test.
// http://en.wikipedia.org/wiki/Curve_orientation#Orientation_of_a_simple_polygon
// rhill 2011-05-21: Nasty finite precision error which caused circumcircle() to
// return infinites: 1e-12 seems to fix the problem.
var d = 2 * (ax * cy - ay * cx);
if (d >= -2e-12) { return; }
var ha = ax * ax + ay * ay,
hc = cx * cx + cy * cy,
x = (cy * ha - ay * hc) / d,
y = (ax * hc - cx * ha) / d,
ycenter = y + by;
// Important: ybottom should always be under or at sweep, so no need
// to waste CPU cycles by checking
// recycle circle event object if possible
var circleEvent = this.circleEventJunkyard.pop();
if (!circleEvent) {
circleEvent = new this.CircleEvent();
}
circleEvent.arc = arc;
circleEvent.site = cSite;
circleEvent.x = x + bx;
circleEvent.y = ycenter + this.sqrt(x * x + y * y); // y bottom
circleEvent.ycenter = ycenter;
arc.circleEvent = circleEvent;
// find insertion point in RB-tree: circle events are ordered from
// smallest to largest
var predecessor = null,
node = this.circleEvents.root;
while (node) {
if (circleEvent.y < node.y || (circleEvent.y === node.y && circleEvent.x <= node.x)) {
if (node.rbLeft) {
node = node.rbLeft;
}
else {
predecessor = node.rbPrevious;
break;
}
}
else {
if (node.rbRight) {
node = node.rbRight;
}
else {
predecessor = node;
break;
}
}
}
this.circleEvents.rbInsertSuccessor(predecessor, circleEvent);
if (!predecessor) {
this.firstCircleEvent = circleEvent;
}
},
detachCircleEvent(arc) {
var circleEvent = arc.circleEvent;
if (circleEvent) {
if (!circleEvent.rbPrevious) {
this.firstCircleEvent = circleEvent.rbNext;
}
this.circleEvents.rbRemoveNode(circleEvent); // remove from RB-tree
this.circleEventJunkyard.push(circleEvent);
arc.circleEvent = null;
}
},
// ---------------------------------------------------------------------------
// Diagram completion methods
// connect dangling edges (not if a cursory test tells us
// it is not going to be visible.
// return value:
// false: the dangling endpoint couldn't be connected
// true: the dangling endpoint could be connected
connectEdge(edge, bbox) {
// skip if end point already connected
var vb = edge.vb;
if (!!vb) { return true; }
// make local copy for performance purpose
var va = edge.va,
xl = bbox.xl,
xr = bbox.xr,
yt = bbox.yt,
yb = bbox.yb,
lSite = edge.lSite,
rSite = edge.rSite,
lx = lSite.x,
ly = lSite.y,
rx = rSite.x,
ry = rSite.y,
fx = (lx + rx) / 2,
fy = (ly + ry) / 2,
fm, fb;
// if we reach here, this means cells which use this edge will need
// to be closed, whether because the edge was removed, or because it
// was connected to the bounding box.
this.cells[lSite.voronoiId].closeMe = true;
this.cells[rSite.voronoiId].closeMe = true;
// get the line equation of the bisector if line is not vertical
if (ry !== ly) {
fm = (lx - rx) / (ry - ly);
fb = fy - fm * fx;
}
// remember, direction of line (relative to left site):
// upward: left.x < right.x
// downward: left.x > right.x
// horizontal: left.x == right.x
// upward: left.x < right.x
// rightward: left.y < right.y
// leftward: left.y > right.y
// vertical: left.y == right.y
// depending on the direction, find the best side of the
// bounding box to use to determine a reasonable start point
// rhill 2013-12-02:
// While at it, since we have the values which define the line,
// clip the end of va if it is outside the bbox.
// https://github.com/gorhill/Javascript-Voronoi/issues/15
// TODO: Do all the clipping here rather than rely on Liang-Barsky
// which does not do well sometimes due to loss of arithmetic
// precision. The code here doesn't degrade if one of the vertex is
// at a huge distance.
// special case: vertical line
if (fm === undefined) {
// doesn't intersect with viewport
if (fx < xl || fx >= xr) { return false; }
// downward
if (lx > rx) {
if (!va || va.y < yt) {
va = this.createVertex(fx, yt);
}
else if (va.y >= yb) {
return false;
}
vb = this.createVertex(fx, yb);
}
// upward
else {
if (!va || va.y > yb) {
va = this.createVertex(fx, yb);
}
else if (va.y < yt) {
return false;
}
vb = this.createVertex(fx, yt);
}
}
// closer to vertical than horizontal, connect start point to the
// top or bottom side of the bounding box
else if (fm < -1 || fm > 1) {
// downward
if (lx > rx) {
if (!va || va.y < yt) {
va = this.createVertex((yt - fb) / fm, yt);
}
else if (va.y >= yb) {
return false;
}
vb = this.createVertex((yb - fb) / fm, yb);
}
// upward
else {
if (!va || va.y > yb) {
va = this.createVertex((yb - fb) / fm, yb);
}
else if (va.y < yt) {
return false;
}
vb = this.createVertex((yt - fb) / fm, yt);
}
}
// closer to horizontal than vertical, connect start point to the
// left or right side of the bounding box
else {
// rightward
if (ly < ry) {
if (!va || va.x < xl) {
va = this.createVertex(xl, fm * xl + fb);
}
else if (va.x >= xr) {
return false;
}
vb = this.createVertex(xr, fm * xr + fb);
}
// leftward
else {
if (!va || va.x > xr) {
va = this.createVertex(xr, fm * xr + fb);
}
else if (va.x < xl) {
return false;
}
vb = this.createVertex(xl, fm * xl + fb);
}
}
edge.va = va;
edge.vb = vb;
return true;
},
// line-clipping code taken from:
// Liang-Barsky function by Daniel White
// http://www.skytopia.com/project/articles/compsci/clipping.html
// Thanks!
// A bit modified to minimize code paths
clipEdge(edge, bbox) {
var ax = edge.va.x,
ay = edge.va.y,
bx = edge.vb.x,
by = edge.vb.y,
t0 = 0,
t1 = 1,
dx = bx - ax,
dy = by - ay;
// left
var q = ax - bbox.xl;
if (dx === 0 && q < 0) { return false; }
var r = -q / dx;
if (dx < 0) {
if (r < t0) { return false; }
if (r < t1) { t1 = r; }
}
else if (dx > 0) {
if (r > t1) { return false; }
if (r > t0) { t0 = r; }
}
// right
q = bbox.xr - ax;
if (dx === 0 && q < 0) { return false; }
r = q / dx;
if (dx < 0) {
if (r > t1) { return false; }
if (r > t0) { t0 = r; }
}
else if (dx > 0) {
if (r < t0) { return false; }
if (r < t1) { t1 = r; }
}
// top
q = ay - bbox.yt;
if (dy === 0 && q < 0) { return false; }
r = -q / dy;
if (dy < 0) {
if (r < t0) { return false; }
if (r < t1) { t1 = r; }
}
else if (dy > 0) {
if (r > t1) { return false; }
if (r > t0) { t0 = r; }
}
// bottom
q = bbox.yb - ay;
if (dy === 0 && q < 0) { return false; }
r = q / dy;
if (dy < 0) {
if (r > t1) { return false; }
if (r > t0) { t0 = r; }
}
else if (dy > 0) {
if (r < t0) { return false; }
if (r < t1) { t1 = r; }
}
// if we reach this point, Voronoi edge is within bbox
// if t0 > 0, va needs to change
// rhill 2011-06-03: we need to create a new vertex rather
// than modifying the existing one, since the existing
// one is likely shared with at least another edge
if (t0 > 0) {
edge.va = this.createVertex(ax + t0 * dx, ay + t0 * dy);
}
// if t1 < 1, vb needs to change
// rhill 2011-06-03: we need to create a new vertex rather
// than modifying the existing one, since the existing
// one is likely shared with at least another edge
if (t1 < 1) {
edge.vb = this.createVertex(ax + t1 * dx, ay + t1 * dy);
}
// va and/or vb were clipped, thus we will need to close
// cells which use this edge.
if (t0 > 0 || t1 < 1) {
this.cells[edge.lSite.voronoiId].closeMe = true;
this.cells[edge.rSite.voronoiId].closeMe = true;
}
return true;
},
// Connect/cut edges at bounding box
clipEdges(bbox) {
// connect all dangling edges to bounding box
// or get rid of them if it can't be done
var edges = this.edges,
iEdge = edges.length,
edge,
abs_fn = Math.abs;
// iterate backward so we can splice safely
while (iEdge--) {
edge = edges[iEdge];
// edge is removed if:
// it is wholly outside the bounding box
// it is looking more like a point than a line
if (!this.connectEdge(edge, bbox) ||
!this.clipEdge(edge, bbox) ||
(abs_fn(edge.va.x - edge.vb.x) < 1e-9 && abs_fn(edge.va.y - edge.vb.y) < 1e-9)) {
edge.va = edge.vb = null;
edges.splice(iEdge, 1);
}
}
},
// Close the cells.
// The cells are bound by the supplied bounding box.
// Each cell refers to its associated site, and a list
// of halfedges ordered counterclockwise.
closeCells(bbox) {
var xl = bbox.xl,
xr = bbox.xr,
yt = bbox.yt,
yb = bbox.yb,
cells = this.cells,
iCell = cells.length,
cell,
iLeft,
halfedges, nHalfedges,
edge,
va, vb, vz,
lastBorderSegment,
abs_fn = Math.abs;
while (iCell--) {
cell = cells[iCell];
// prune, order halfedges counterclockwise, then add missing ones
// required to close cells
if (!cell.prepareHalfedges()) {
continue;
}
if (!cell.closeMe) {
continue;
}
// find first 'unclosed' point.
// an 'unclosed' point will be the end point of a halfedge which
// does not match the start point of the following halfedge
halfedges = cell.halfedges;
nHalfedges = halfedges.length;
// special case: only one site, in which case, the viewport is the cell
// ...
// all other cases
iLeft = 0;
while (iLeft < nHalfedges) {
va = halfedges[iLeft].getEndpoint();
vz = halfedges[(iLeft + 1) % nHalfedges].getStartpoint();
// if end point is not equal to start point, we need to add the missing
// halfedge(s) up to vz
if (abs_fn(va.x - vz.x) >= 1e-9 || abs_fn(va.y - vz.y) >= 1e-9) {
// rhill 2013-12-02:
// "Holes" in the halfedges are not necessarily always adjacent.
// https://github.com/gorhill/Javascript-Voronoi/issues/16
// find entry point:
switch (true) {
// walk downward along left side
case this.equalWithEpsilon(va.x, xl) && this.lessThanWithEpsilon(va.y, yb):
lastBorderSegment = this.equalWithEpsilon(vz.x, xl);
vb = this.createVertex(xl, lastBorderSegment ? vz.y : yb);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
va = vb;
// fall through
// walk rightward along bottom side
case this.equalWithEpsilon(va.y, yb) && this.lessThanWithEpsilon(va.x, xr):
lastBorderSegment = this.equalWithEpsilon(vz.y, yb);
vb = this.createVertex(lastBorderSegment ? vz.x : xr, yb);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
va = vb;
// fall through
// walk upward along right side
case this.equalWithEpsilon(va.x, xr) && this.greaterThanWithEpsilon(va.y, yt):
lastBorderSegment = this.equalWithEpsilon(vz.x, xr);
vb = this.createVertex(xr, lastBorderSegment ? vz.y : yt);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
va = vb;
// fall through
// walk leftward along top side
case this.equalWithEpsilon(va.y, yt) && this.greaterThanWithEpsilon(va.x, xl):
lastBorderSegment = this.equalWithEpsilon(vz.y, yt);
vb = this.createVertex(lastBorderSegment ? vz.x : xl, yt);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
va = vb;
// fall through
// walk downward along left side
lastBorderSegment = this.equalWithEpsilon(vz.x, xl);
vb = this.createVertex(xl, lastBorderSegment ? vz.y : yb);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
va = vb;
// fall through
// walk rightward along bottom side
lastBorderSegment = this.equalWithEpsilon(vz.y, yb);
vb = this.createVertex(lastBorderSegment ? vz.x : xr, yb);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
va = vb;
// fall through
// walk upward along right side
lastBorderSegment = this.equalWithEpsilon(vz.x, xr);
vb = this.createVertex(xr, lastBorderSegment ? vz.y : yt);
edge = this.createBorderEdge(cell.site, va, vb);
iLeft++;
halfedges.splice(iLeft, 0, this.createHalfedge(edge, cell.site, null));
nHalfedges++;
if (lastBorderSegment) { break; }
// fall through
default:
throw "Voronoi.closeCells() > this makes no sense!";
}
}
iLeft++;
}
cell.closeMe = false;
}
},
// ---------------------------------------------------------------------------
// Debugging helper
/*
Voronoi.prototype.dumpBeachline = function(y) {
console.log('Voronoi.dumpBeachline(%f) > Beachsections, from left to right:', y);
if ( !this.beachline ) {
console.log(' None');
}
else {
var bs = this.beachline.getFirst(this.beachline.root);
while ( bs ) {
console.log(' site %d: xl: %f, xr: %f', bs.site.voronoiId, this.leftBreakPoint(bs, y), this.rightBreakPoint(bs, y));
bs = bs.rbNext;
}
}
};
*/
// ---------------------------------------------------------------------------
// Helper: Quantize sites
// rhill 2013-10-12:
// This is to solve https://github.com/gorhill/Javascript-Voronoi/issues/15
// Since not all users will end up using the kind of coord values which would
// cause the issue to arise, I chose to let the user decide whether or not
// he should sanitize his coord values through this helper. This way, for
// those users who uses coord values which are known to be fine, no overhead is
// added.
quantizeSites(sites) {
var ε = this.ε,
n = sites.length,
site;
while (n--) {
site = sites[n];
site.x = Math.floor(site.x / ε) * ε;
site.y = Math.floor(site.y / ε) * ε;
}
},
// ---------------------------------------------------------------------------
// Helper: Recycle diagram: all vertex, edge and cell objects are
// "surrendered" to the Voronoi object for reuse.
// TODO: rhill-voronoi-core v2: more performance to be gained
// when I change the semantic of what is returned.
recycle(diagram) {
if (diagram) {
if (diagram instanceof this.Diagram) {
this.toRecycle = diagram;
}
else {
throw 'Voronoi.recycleDiagram() > Need a Diagram object.';
}
}
},
// ---------------------------------------------------------------------------
// Top-level Fortune loop
// rhill 2011-05-19:
// Voronoi sites are kept client-side now, to allow
// user to freely modify content. At compute time,
// *references* to sites are copied locally.
compute(sites, bbox) {
// to measure execution time
var startTime = new Date();
// init internal state
this.reset();
// any diagram data available for recycling?
// I do that here so that this is included in execution time
if (this.toRecycle) {
this.vertexJunkyard = this.vertexJunkyard.concat(this.toRecycle.vertices);
this.edgeJunkyard = this.edgeJunkyard.concat(this.toRecycle.edges);
this.cellJunkyard = this.cellJunkyard.concat(this.toRecycle.cells);
this.toRecycle = null;
}
// Initialize site event queue
var siteEvents = sites.slice(0);
siteEvents.sort(function (a, b) {
var r = b.y - a.y;
if (r) { return r; }
return b.x - a.x;
});
// process queue
var site = siteEvents.pop(),
siteid = 0,
xsitex, // to avoid duplicate sites
xsitey,
cells = this.cells,
circle;
// main loop
for (; ;) {
// we need to figure whether we handle a site or circle event
// for this we find out if there is a site event and it is
// 'earlier' than the circle event
circle = this.firstCircleEvent;
// add beach section
if (site && (!circle || site.y < circle.y || (site.y === circle.y && site.x < circle.x))) {
// only if site is not a duplicate
if (site.x !== xsitex || site.y !== xsitey) {
// first create cell for new site
cells[siteid] = this.createCell(site);
site.voronoiId = siteid++;
// then create a beachsection for that site
this.addBeachsection(site);
// remember last site coords to detect duplicate
xsitey = site.y;
xsitex = site.x;
}
site = siteEvents.pop();
}
// remove beach section
else if (circle) {
this.removeBeachsection(circle.arc);
}
// all done, quit
else {
break;
}
}
// wrapping-up:
// connect dangling edges to bounding box
// cut edges as per bounding box
// discard edges completely outside bounding box
// discard edges which are point-like
this.clipEdges(bbox);
// add missing edges in order to close opened cells
this.closeCells(bbox);
// to measure execution time
var stopTime = new Date();
// prepare return values
var diagram = new this.Diagram();
diagram.cells = this.cells;
diagram.edges = this.edges;
diagram.vertices = this.vertices;
diagram.execTime = stopTime.getTime() - startTime.getTime();
// clean up
this.reset();
return diagram;
},
};
|
// example configuration of how data used to mock up the GA config getting used in Drupal
window.drupalSettings = {
google_analytics: {
trackCrossDomains: ['developer.mozilla.org'],
},
};
const TRACKING_ID = 'UA-127403924-1';
// eslint-disable-next-line no-return-assign
window.ga = window.ga || ((...args) => (ga.q = ga.q || []).push(args));
ga('create', TRACKING_ID, 'auto', { allowLinker: true });
ga('send', 'pageview');
ga('set', 'transport', 'beacon');
ga('require', 'linker');
ga('linker:autoLink', window.drupalSettings.google_analytics.trackCrossDomains);
|
'use strict';
const path = require('path');
const fs = require('fs');
const glob = require('glob');
const fm = require('front-matter');
const test = require('tape');
const dedent = require('dedent-js');
// Splits a string, normalizing line endings and filtering empty lines
const split =
str => str.replace(/\r\n|\r/g, '\n')
.split(/\n/g)
.filter(line => line.trim().length);
// Plucks keys from an object
const pluck = (keys, from) => {
return keys.reduce((obj, key) => {
if (from.hasOwnProperty(key)) {
obj[key] = from[key];
}
return obj;
}, {});
};
/**
* Compares a data file with a comparator file. Each transform function
* is passed an object containing the its respective data as `value`, the
* yaml front matter as `header`, the data file name as `dataFile`, and
* the comparator file as `comparatorFile`.
*
* The modifiers are "error", "expected", and "multiple", where "multiple"
* modifies the first two.
*
* "error" expects the data transform to throw an
* error, and throws one itself if it doesn't. The error object is compared
* against the user returned comparator.
*
* "expected" checks deep equality of the two transform results.
*
* "multiple" will run the transforms on each line of each file. Empty lines
* are ignored.
*
* @param {String} pattern - The pattern for the data files
* @param {Function} options.transform.data
* - The transform for the data before it's compared
* @param {Function} options.transform.comparator
* - The transform for the comparator data before it's compared
* @param {Object} options.ext.data - The ext for data files (required)
* @return {void}
*/
function compare(pattern, options) {
const {
prefix='',
depth: objectPrintDepth=30,
exclude,
errorProps=['message', 'line', 'column'],
transform,
ext: { data: dExt='js', comparator: cExt='json' }={},
} = options;
if ([dExt, cExt].some(ext => typeof ext !== 'string')) {
throw new Error('compare: Invalid extentions');
}
const comparatorExt = cExt.replace(/^\.+/g, '');
const dataExt = dExt.replace(/^\.+/g, '');
const regext = new RegExp(`.${comparatorExt}$`);
const files =
glob
.sync(pattern, { exclude })
.filter(file => regext.test(file));
let stop = false;
files.forEach(file => {
const dir = path.dirname(file);
const ext = path.extname(file);
const basename = path.basename(file, ext);
const [base, ...modifiers] = path.basename(file, ext).split(/\./);
const comparatorFile = `${dir}/${basename}.${comparatorExt}`;
const dataFile = `${dir}/${base}.${dataExt}`;
let data = fs.readFileSync(dataFile, 'utf8');
let comparatorData = fs.readFileSync(comparatorFile, 'utf8');
const { attributes: header, body: comparator } = fm(comparatorData);
const hasMultiple = modifiers.includes('multiple');
const only = header.only ? 'only' : null;
const skip = header.skip ? 'skip' : null;
const title = prefix + header.name;
let fn = null;
let dataWrapper = null;
let comparatorWrapper = null;
// Normalize to an array of items
if (hasMultiple) {
dataWrapper = split(data);
comparatorWrapper = split(comparator);
} else {
dataWrapper = [data];
comparatorWrapper = [comparator];
}
if (modifiers.includes('expected')) {
fn = t => {
// Map through the comparators since it declares the standard
try {
comparatorWrapper.forEach((comparator, index) => {
const transformArgs = {
comparator,
data: dataWrapper[index],
dataFile,
comparatorFile,
header,
};
const actual = transform.data(transformArgs);
const expected = transform.comparator(transformArgs);
t.deepEquals(actual, expected, header.description);
});
} catch (err) {
throw new Error(
dedent`
compare: deepEqual check threw, use "error" modifier to compare errors:
from: ${dataFile}
${err.stack}
`
);
}
t.end();
};
} else if (modifiers.includes('error')) {
fn = t => {
comparatorWrapper.forEach((comparator, index) => {
const transformArgs = {
comparator,
data: dataWrapper[index],
dataFile,
comparatorFile,
header,
};
try {
transform.data(transformArgs);
throw new Error(`compare: Error was not thrown ${dataFile}`);
} catch (err) {
const actual = pluck(errorProps, err);
const expected = transform.comparator(transformArgs);
t.deepEquals(
actual,
expected,
(hasMultiple ? `#${index} ` : '') + header.description
);
}
});
t.end();
};
} else {
const message =
`Unknown modifier "${modifiers}" from filename ${dataFile}`;
throw new Error(message);
}
// tape will throw with multiple onlys, so we have to stop
if (stop) {
return;
}
if (only) {
test.only(title, { objectPrintDepth }, fn);
stop = true;
} else if (skip) {
if (options.onSkip) {
options.onSkip(dataFile);
}
test.skip(title, { objectPrintDepth }, fn);
} else {
test(title, { objectPrintDepth }, fn);
}
});
}
module.exports = compare;
|
var files = require('./files');
var parser = require('./parser');
var yaml = require('js-yaml');
var fs = require('fs');
var _ = require('lodash');
/**
* Executes the conversion process. Depending on the given config, .json files are deflated into .properties or
* .propeties file are inflated into .json files. These processes are executed on each file identified within the src
* directory identified by the src attribute of the provided options.config, and outputs the resultant file of each
* input file within the destination directory identified by the dist attribute.
*
* @param options A json file having the following attributes:
* - config : An object having a src and dist attribute, identifying the source and destination directory
* respectively. Defaults to the current path if not provided.
* - reverse : A flag denoting if the reverse process, ie. converting properties to json should be done, and
* timestamp. Defaults to false.
* - timestamp: A flag identifying if a timestamp is to be prepended to the resultant files. Defaults to false.
*/
exports.processOptions = function (options) {
var config = options.config;
var data = yaml.safeLoad(fs.readFileSync(config.src, 'utf8'));
var entries = parser.deflate(data); // Convert the JSON structure into an array of strings
var dist = config.dist.split('/');
var distFile = _.replace(_.last(dist), 'properties', 'json');
var distDir = _.replace(config.dist, '/' + distFile, '');
files.writeAsProperties(distDir, distFile, entries); // Writes the parsed result to the dist directory
};
/**
* Consumes the provided options object and merges it with the default options. The conversion process is triggered
* upon the resultant options object.
*
* @param options A json file having the following attributes:
* - config : An object having a src and dist attribute, identifying the source and destination directory
* respectively. Defaults to the current path if not provided.
* - reverse : A flag denoting if the reverse process, ie. converting properties to json should be done, and
* timestamp. Defaults to false.
* - timestamp: A flag identifying if a timestamp is to be prepended to the resultant files. Defaults to false.
*/
exports.process = function (options) {
// Identify the current path
var path = process.cwd();
// The default options
var _options = {
config: { src: path, dist: path },
reverse: false,
spaces: 4
};
for (var key in options) {
if (options.hasOwnProperty(key) && options[ key ]) {
_options[ key ] = options[ key ];
}
}
exports.processOptions(_options);
};
|
function EnglishDigit(input) {
var num = input[0];
var numToString = input.toString(); // pravim si 4isloto v string, za da si vzemem posledniq mu element, po-lesno
var lastDigit = +numToString.slice(-1); // vzimame posledniq element of stringa- v slu4aq poslednata cifra ot 4islo vzima//
if (lastDigit === 0) {
console.log('zero');
}
else if (lastDigit === 1) {
console.log('one');
}
else if (lastDigit === 2) {
console.log('two');
}
else if (lastDigit === 3) {
console.log('three');
}
else if (lastDigit === 4) {
console.log('four');
}
else if (lastDigit === 5) {
console.log('five');
}
else if (lastDigit === 6) {
console.log('six');
}
else if (lastDigit === 7) {
console.log('seven');
}
else if (lastDigit === 8) {
console.log('eight');
}
else {
console.log('nine');
}
}
// vtori na4in:
function digit(number) {
var num = String(number),
digit = num[num.length - 1];
switch (digit) {
case '0': return 'zero';
case '1': return 'one';
case '2': return 'two';
case '3': return 'three';
case '4': return 'four';
case '5': return 'five';
case '6': return 'six';
case '7': return 'seven';
case '8': return 'eight';
case '9': return 'nine';
default:
break;
}
} |
/*!
* Angular Material Design
* https://github.com/angular/material
* @license MIT
* v0.9.0-rc2-master-041ffe9
*/
goog.provide('ng.material.components.tooltip');
goog.require('ng.material.core');
/**
* @ngdoc module
* @name material.components.tooltip
*/
angular
.module('material.components.tooltip', [ 'material.core' ])
.directive('mdTooltip', MdTooltipDirective);
/**
* @ngdoc directive
* @name mdTooltip
* @module material.components.tooltip
* @description
* Tooltips are used to describe elements that are interactive and primarily graphical (not textual).
*
* Place a `<md-tooltip>` as a child of the element it describes.
*
* A tooltip will activate when the user focuses, hovers over, or touches the parent.
*
* @usage
* <hljs lang="html">
* <md-button class="md-fab md-accent" aria-label="Play">
* <md-tooltip>
* Play Music
* </md-tooltip>
* <md-icon icon="/img/icons/ic_play_arrow_24px.svg"></md-icon>
* </md-button>
* </hljs>
*
* @param {expression=} md-visible Boolean bound to whether the tooltip is
* currently visible.
* @param {number=} md-delay How many milliseconds to wait to show the tooltip after the user focuses, hovers, or touches the parent. Defaults to 400ms.
* @param {string=} md-direction Which direction would you like the tooltip to go? Supports left, right, top, and bottom. Defaults to bottom.
* @param {boolean=} md-autohide If present or provided with a boolean value, the tooltip will hide on mouse leave, regardless of focus
*/
function MdTooltipDirective($timeout, $window, $$rAF, $document, $mdUtil, $mdTheming, $rootElement, $animate, $q) {
var TOOLTIP_SHOW_DELAY = 300;
var TOOLTIP_WINDOW_EDGE_SPACE = 8;
return {
restrict: 'E',
transclude: true,
template: '\
<div class="md-background"></div>\
<div class="md-content" ng-transclude></div>',
scope: {
visible: '=?mdVisible',
delay: '=?mdDelay',
autohide: '=?mdAutohide'
},
link: postLink
};
function postLink(scope, element, attr) {
$mdTheming(element);
var parent = getParentWithPointerEvents(),
background = angular.element(element[0].getElementsByClassName('md-background')[0]),
content = angular.element(element[0].getElementsByClassName('md-content')[0]),
direction = attr.mdDirection,
current = getNearestContentElement(),
tooltipParent = angular.element(current || document.body),
debouncedOnResize = $$rAF.throttle(function () { if (scope.visible) positionTooltip(); });
return init();
function init () {
setDefaults();
manipulateElement();
bindEvents();
configureWatchers();
}
function setDefaults () {
if (!angular.isDefined(attr.mdDelay)) scope.delay = TOOLTIP_SHOW_DELAY;
}
function configureWatchers () {
scope.$watch('visible', function (isVisible) {
if (isVisible) showTooltip();
else hideTooltip();
});
scope.$on('$destroy', function() {
scope.visible = false;
element.remove();
angular.element($window).off('resize', debouncedOnResize);
});
}
function manipulateElement () {
element.detach();
element.attr('role', 'tooltip');
element.attr('id', attr.id || ('tooltip_' + $mdUtil.nextUid()));
}
function getParentWithPointerEvents () {
var parent = element.parent();
while ($window.getComputedStyle(parent[0])['pointer-events'] == 'none') {
parent = parent.parent();
}
return parent;
}
function getNearestContentElement () {
var current = element.parent()[0];
// Look for the nearest parent md-content, stopping at the rootElement.
while (current && current !== $rootElement[0] && current !== document.body) {
if (current.tagName && current.tagName.toLowerCase() == 'md-content') break;
current = current.parentNode;
}
return current;
}
function bindEvents () {
var autohide = scope.hasOwnProperty('autohide') ? scope.autohide : attr.hasOwnProperty('mdAutohide');
parent.on('focus mouseenter touchstart', function() { setVisible(true); });
parent.on('blur mouseleave touchend touchcancel', function() { if ($document[0].activeElement !== parent[0] || autohide) setVisible(false); });
angular.element($window).on('resize', debouncedOnResize);
}
function setVisible (value) {
setVisible.value = !!value;
if (!setVisible.queued) {
if (value) {
setVisible.queued = true;
$timeout(function() {
scope.visible = setVisible.value;
setVisible.queued = false;
}, scope.delay);
} else {
$timeout(function() { scope.visible = false; });
}
}
}
function showTooltip() {
// Insert the element before positioning it, so we can get the position
// and check if we should display it
tooltipParent.append(element);
// Check if we should display it or not.
// This handles hide-* and show-* along with any user defined css
var computedStyles = $window.getComputedStyle(element[0]);
if (angular.isDefined(computedStyles.display) && computedStyles.display == 'none') {
element.detach();
return;
}
parent.attr('aria-describedby', element.attr('id'));
positionTooltip();
angular.forEach([element, background, content], function (element) {
$animate.addClass(element, 'md-show');
});
}
function hideTooltip() {
parent.removeAttr('aria-describedby');
$q.all([
$animate.removeClass(content, 'md-show'),
$animate.removeClass(background, 'md-show'),
$animate.removeClass(element, 'md-show')
]).then(function () {
if (!scope.visible) element.detach();
});
}
function positionTooltip() {
var tipRect = $mdUtil.offsetRect(element, tooltipParent);
var parentRect = $mdUtil.offsetRect(parent, tooltipParent);
var newPosition = getPosition(direction);
// If the user provided a direction, just nudge the tooltip onto the screen
// Otherwise, recalculate based on 'top' since default is 'bottom'
if (direction) {
newPosition = fitInParent(newPosition);
} else if (newPosition.top > element.prop('offsetParent').scrollHeight - tipRect.height - TOOLTIP_WINDOW_EDGE_SPACE) {
newPosition = fitInParent(getPosition('top'));
}
element.css({top: newPosition.top + 'px', left: newPosition.left + 'px'});
positionBackground();
function positionBackground () {
var size = direction === 'left' || direction === 'right'
? Math.sqrt(Math.pow(tipRect.width, 2) + Math.pow(tipRect.height / 2, 2)) * 2
: Math.sqrt(Math.pow(tipRect.width / 2, 2) + Math.pow(tipRect.height, 2)) * 2,
position = direction === 'left' ? { left: 100, top: 50 }
: direction === 'right' ? { left: 0, top: 50 }
: direction === 'top' ? { left: 50, top: 100 }
: { left: 50, top: 0 };
background.css({
width: size + 'px',
height: size + 'px',
left: position.left + '%',
top: position.top + '%'
});
}
function fitInParent (pos) {
var newPosition = { left: pos.left, top: pos.top };
newPosition.left = Math.min( newPosition.left, tooltipParent.prop('scrollWidth') - tipRect.width - TOOLTIP_WINDOW_EDGE_SPACE );
newPosition.left = Math.max( newPosition.left, TOOLTIP_WINDOW_EDGE_SPACE );
newPosition.top = Math.min( newPosition.top, tooltipParent.prop('scrollHeight') - tipRect.height - TOOLTIP_WINDOW_EDGE_SPACE );
newPosition.top = Math.max( newPosition.top, TOOLTIP_WINDOW_EDGE_SPACE );
return newPosition;
}
function getPosition (dir) {
return dir === 'left'
? { left: parentRect.left - tipRect.width - TOOLTIP_WINDOW_EDGE_SPACE,
top: parentRect.top + parentRect.height / 2 - tipRect.height / 2 }
: dir === 'right'
? { left: parentRect.left + parentRect.width + TOOLTIP_WINDOW_EDGE_SPACE,
top: parentRect.top + parentRect.height / 2 - tipRect.height / 2 }
: dir === 'top'
? { left: parentRect.left + parentRect.width / 2 - tipRect.width / 2,
top: parentRect.top - tipRect.height - TOOLTIP_WINDOW_EDGE_SPACE }
: { left: parentRect.left + parentRect.width / 2 - tipRect.width / 2,
top: parentRect.top + parentRect.height + TOOLTIP_WINDOW_EDGE_SPACE };
}
}
}
}
MdTooltipDirective.$inject = ["$timeout", "$window", "$$rAF", "$document", "$mdUtil", "$mdTheming", "$rootElement", "$animate", "$q"];
ng.material.components.tooltip = angular.module("material.components.tooltip"); |
var express = require('express');
var config = require('../profile.json');
var router = express.Router();
// var Accounts = require(config.models_factary)("account");
var main = require(config.main_mp2);
var login = require(config.login_mp);
var customer = require(config.customer_mp);
router.get('/', main.authorize_session_only_username, login.loginface);
router.post('/login:id', login.loginAction);
router.get('/admin', main.authorize_session_only_username, (req, res, next) => {
res.render('admin', { layout: "admin", title: 'Express' });
});
router.get('/putuser', login.tempAddUser);
router.get('/customersList', main.authorize_session_only_username,customer.customersList);
router.get('/myinfo',customer.myinfo)
// router.get('/getuser', (req, res, next) =>{
// Accounts.find( (err, response) =>{
// if (err) {
// console.log("查询失败" + err);
// }
// else {
// console.log("Res:" + response);
// res.send('查询成功' + response);
// }
// });
// });
module.exports = router;
|
/**
* @return the root <html> tag.
*/
function getRootHtmlTag () {
return document.getElementsByTagName('html')[0]
}
/**
* Add print-view class to the html tag on print layout components
* to ensure that iOS scroll fix only applies to non-print views.
*/
export function addPrintViewClassToRootHtml () {
getRootHtmlTag().setAttribute('class', 'print-view')
}
/**
* Remove class attribute from html tag,
* for print layout components when componentWillUnmount runs.
*/
export function clearClassFromRootHtml () {
getRootHtmlTag().removeAttribute('class')
}
|
var slowest, i, entries = performance.getEntries();
slowest = entries[0];
for (i=0; i<entries.length; i++) {
if (entries[i].duration > slowest.duration) slowest = entries[i];
}
console.log(slowest); |
/**
* Handles Error Defintions
*/
/**
* Creates Error classes
*
* @param {String} message
* @return {Error}
*/
function defineError(message) {
var _Error = function(customMessage) {
this.message = customMessage || message;
}
_Error.prototype = Object.create(Error.prototype);
_Error.prototype.constructor = _Error;
return _Error;
}
// Error Defintions
exports = module.exports = {
PackageJSONNotFoundError: defineError("package.json not found"),
PackageVersionNotFoundError: defineError("Package version does not exit")
};
|
"use strict";
module.exports = {
"extends": [
"./rules/react",
"./rules/react-hooks"
].map((path) => require.resolve(path)),
"env": {
"browser": true
},
"parserOptions": {
"ecmaVersion": 2018,
"sourceType": "module"
}
};
|
System.config({
transpiler: 'typescript',
typescriptOptions: {
emitDecoratorMetadata: true
},
map: {
app: './app'
},
packages: {
app: {
main: './main.ts',
defaultExtension: 'ts'
}
}
}); |
import { attr } from '@ember-data/model';
import BaseModel from './base';
export default class AttachmentModel extends BaseModel {
@attr('rendered') title;
@attr media_details;
@attr('string') source_url;
@attr('rendered') caption;
@attr('rendered') description;
}
|
"use strict";
const express = require('express');
const _ = require('lodash');
const path = require('path');
const router = express.Router();
const news = require('../controllers/news.js');
const weather = require('../controllers/weather.js');
const uppers = require('../controllers/uppers.js');
router.get('/api', (req, res) => {
// res.header('Access-Control-Allow-Origin', '*');
res.send({'hello': 'world'});
});
//example of recieving JSON as a post request
//use postman to test this
router.post('/api', uppers);
router.get('/api/weather', weather.api);
router.get('/api/news', news.api);
module.exports = router; |
'use strict';
angular.module('myApp', [
'ngRoute',
'myApp.filters',
'myApp.services',
'myApp.directives',
'myApp.controllers'
]).
config(['$routeProvider', function($routeProvider) {
$routeProvider.when('/map', {templateUrl: 'partials/map.html', controller: 'mapPageCtrl'});
$routeProvider.otherwise({redirectTo: '/map'});
}]);
|
import {renderToString} from 'react-dom/server';
import {createMemoryHistory, match, RouterContext} from 'react-router';
import {syncHistoryWithStore} from 'react-router-redux';
import {StyleSheetServer} from 'aphrodite';
import routes from '../../routes';
import {ApolloProvider} from 'react-apollo';
import ApolloClientSingleton from '../../network/apollo-client-singleton';
import React from 'react';
import renderIndex from './render-index';
import Store from '../../store';
import wrap from '../wrap';
import fs from 'fs';
import path from 'path';
let assetMap = {
'bundle.js': 'bundle.js'
};
if (process.env.NODE_ENV === 'production') {
assetMap = JSON.parse(
fs.readFileSync(
path.join(process.env.ASSETS_DIR, process.env.ASSETS_MAP_FILE)
)
);
}
export default wrap(async (req, res) => {
const memoryHistory = createMemoryHistory(req.url);
const store = new Store(memoryHistory);
const history = syncHistoryWithStore(memoryHistory, store.data);
match(
{
history,
routes,
location: req.url
},
(error, redirectLocation, renderProps) => {
if (error) {
res.status(500).send(error.message);
} else if (redirectLocation) {
res.redirect(302, redirectLocation.pathname + redirectLocation.search);
} else if (renderProps) {
const {html, css} = StyleSheetServer.renderStatic(() =>
renderToString(
<ApolloProvider store={store.data} client={ApolloClientSingleton}>
<RouterContext {...renderProps} />
</ApolloProvider>
)
);
res.send(renderIndex(html, css, assetMap, store.data));
} else {
res.status(404).send('Not found');
}
}
);
});
|
import React from 'react';
import { Message } from 'semantic-ui-react';
const NotFound = props => (
<div>
<Message negative>
<Message.Header>404</Message.Header>
<p>Sorry, that page could not be found</p>
</Message>
</div>
);
export default NotFound;
|
$(function() {
// Cache the window object
var $window = $(window);
// Parallax background effect
$("section[data-type='background']").each(function() {
var $bgobj = $(this); // assigning the object
$(window).scroll(function() {
// scroll the background at var speed
// the yPos is a negative value because we are scrolling it UP!
var yPos = -($window.scrollTop() / $bgobj.data("speed"));
// Put together our final background position
var coords = "50% " + yPos + "px";
// Move the background
$bgobj.css({backgroundPosition: coords});
}); // end window scroll
});
}); |
// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
// requestAnimationFrame polyfill by Erik M�ller
// fixes from Paul Irish and Tino Zijdel
(function() {
var lastTime = 0;
var vendors = ['ms', 'moz', 'webkit', 'o'];
for(var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
window.requestAnimationFrame = window[vendors[x]+'RequestAnimationFrame'];
window.cancelAnimationFrame = window[vendors[x]+'CancelAnimationFrame']
|| window[vendors[x]+'CancelRequestAnimationFrame'];
}
if (!window.requestAnimationFrame)
window.requestAnimationFrame = function(callback, element) {
var currTime = new Date().getTime();
var timeToCall = Math.max(0, 16 - (currTime - lastTime));
var id = window.setTimeout(function() { callback(currTime + timeToCall); },
timeToCall);
lastTime = currTime + timeToCall;
return id;
};
if (!window.cancelAnimationFrame)
window.cancelAnimationFrame = function(id) {
clearTimeout(id);
};
}()); |
"use strict";
var core_1 = require('@angular/core');
var _reflect = Reflect;
/**
* @private
*/
function Page(config) {
return function (cls) {
// deprecated warning: added beta.8 2016-05-27
void 0;
config.selector = 'ion-page';
config.host = config.host || {};
config.host['[hidden]'] = '_hidden';
config.host['[class.tab-subpage]'] = '_tabSubPage';
var annotations = _reflect.getMetadata('annotations', cls) || [];
annotations.push(new core_1.Component(config));
_reflect.defineMetadata('annotations', annotations, cls);
return cls;
};
}
exports.Page = Page;
|
/**
* ImageController
*
* @description :: Server-side logic for managing images
* @help :: See http://sailsjs.org/#!/documentation/concepts/Controllers
*/
module.exports = {
};
|
define(["require", "exports", "@microsoft/load-themed-styles"], function (require, exports, load_themed_styles_1) {
"use strict";
var styles = {};
load_themed_styles_1.loadStyles([{ "rawString": ".ms-TooltipExample{margin-top:30px;text-align:center}" }]);
return styles;
});
/* tslint:enable */
//# sourceMappingURL=TooltipPage.scss.js.map
|
import React from 'react'
import { makeStyles } from '@material-ui/core/styles'
import Typography from '@material-ui/core/Typography'
export default ({ text, icon }) => {
const cx = useStyles()
return (
<div className={cx.root}>
<div className={cx.container}>
{icon}
<div className={cx.text}>
<Typography gutterBottom variant='h2' className={cx.title}>
{text}
</Typography>
</div>
</div>
</div>
)
}
const useStyles = makeStyles(theme => ({
text: {
maxWidth: 300,
marginLeft: theme.spacing(2)
},
root: {
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
flex: 1,
alignSelf: 'stretch',
justifySelf: 'stretch'
},
container: {
color: '#00052b',
display: 'flex',
alignItems: 'flex-start',
justifyContent: 'center'
},
title: {
fontSize: '2em',
fontWeight: 400
}
}))
|
(function(angular, undefined) {
'use strict';
angular.module('chat.constants', [])
.constant('appConfig', {userRoles:['guest','user','admin']})
;
})(angular); |
Number.prototype.setSlotsIfAbsent(
{
cssString: function()
{
return this.toString();
},
milliseconds: function()
{
return this;
},
seconds: function()
{
return Number(this) * 1000;
},
minutes: function()
{
return this.seconds() * 60;
},
hours: function()
{
return this.minutes() * 60;
},
days: function()
{
return this.hours() * 24;
},
years: function()
{
return this.days() * 365;
},
repeat: function(callback)
{
for(var i = 0; i < this; i++)
{
callback(i);
}
return this;
},
map: function()
{
var a = [];
for(var i = 0; i < this; i ++)
{
a.push(i);
}
return Array.prototype.map.apply(a, arguments);
},
isEven: function()
{
return this % 2 == 0;
},
abs: function()
{
return Math.abs(this);
}
});
|
//@steal-clean
//
// LESS - Leaner CSS v1.0.34
// http://lesscss.org
//
// Copyright (c) 2010, Alexis Sellier
// Licensed under the Apache 2.0 License.
//
(function (window, undefined) {
//
// Stub out `require` in the browser
//
function require(arg) {
return window.less[arg.split('/')[1]];
};
// ecma-5.js
//
// -- kriskowal Kris Kowal Copyright (C) 2009-2010 MIT License
// -- tlrobinson Tom Robinson
// dantman Daniel Friesen
//
// Array
//
if (!Array.isArray) {
Array.isArray = function(obj) {
return Object.prototype.toString.call(obj) === "[object Array]" ||
(obj instanceof Array);
};
}
if (!Array.prototype.forEach) {
Array.prototype.forEach = function(block, thisObject) {
var len = this.length >>> 0;
for (var i = 0; i < len; i++) {
if (i in this) {
block.call(thisObject, this[i], i, this);
}
}
};
}
if (!Array.prototype.map) {
Array.prototype.map = function(fun /*, thisp*/) {
var len = this.length >>> 0;
var res = new Array(len);
var thisp = arguments[1];
for (var i = 0; i < len; i++) {
if (i in this) {
res[i] = fun.call(thisp, this[i], i, this);
}
}
return res;
};
}
if (!Array.prototype.filter) {
Array.prototype.filter = function (block /*, thisp */) {
var values = [];
var thisp = arguments[1];
for (var i = 0; i < this.length; i++) {
if (block.call(thisp, this[i])) {
values.push(this[i]);
}
}
return values;
};
}
if (!Array.prototype.reduce) {
Array.prototype.reduce = function(fun /*, initial*/) {
var len = this.length >>> 0;
var i = 0;
// no value to return if no initial value and an empty array
if (len === 0 && arguments.length === 1) throw new TypeError();
if (arguments.length >= 2) {
var rv = arguments[1];
} else {
do {
if (i in this) {
rv = this[i++];
break;
}
// if array contains no values, no initial value to return
if (++i >= len) throw new TypeError();
} while (true);
}
for (; i < len; i++) {
if (i in this) {
rv = fun.call(null, rv, this[i], i, this);
}
}
return rv;
};
}
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (value /*, fromIndex */ ) {
var length = this.length;
var i = arguments[1] || 0;
if (!length) return -1;
if (i >= length) return -1;
if (i < 0) i += length;
for (; i < length; i++) {
if (!Object.prototype.hasOwnProperty.call(this, i)) { continue }
if (value === this[i]) return i;
}
return -1;
};
}
//
// Object
//
if (!Object.keys) {
Object.keys = function (object) {
var keys = [];
for (var name in object) {
if (Object.prototype.hasOwnProperty.call(object, name)) {
keys.push(name);
}
}
return keys;
};
}
//
// String
//
if (!String.prototype.trim) {
String.prototype.trim = function () {
return String(this).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
};
}
var less, tree;
if (typeof(window) === 'undefined') {
less = exports,
tree = require('less/tree');
} else {
if (typeof(window.less) === 'undefined') { window.less = {} }
less = window.less,
tree = window.less.tree = {};
}
//
// less.js - parser
//
// A relatively straight-forward predictive parser.
// There is no tokenization/lexing stage, the input is parsed
// in one sweep.
//
// To make the parser fast enough to run in the browser, several
// optimization had to be made:
//
// - Matching and slicing on a huge input is often cause of slowdowns.
// The solution is to chunkify the input into smaller strings.
// The chunks are stored in the `chunks` var,
// `j` holds the current chunk index, and `current` holds
// the index of the current chunk in relation to `input`.
// This gives us an almost 4x speed-up.
//
// - In many cases, we don't need to match individual tokens;
// for example, if a value doesn't hold any variables, operations
// or dynamic references, the parser can effectively 'skip' it,
// treating it as a literal.
// An example would be '1px solid #000' - which evaluates to itself,
// we don't need to know what the individual components are.
// The drawback, of course is that you don't get the benefits of
// syntax-checking on the CSS. This gives us a 50% speed-up in the parser,
// and a smaller speed-up in the code-gen.
//
//
// Token matching is done with the `$` function, which either takes
// a terminal string or regexp, or a non-terminal function to call.
// It also takes care of moving all the indices forwards.
//
//
less.Parser = function Parser(env) {
var input, // LeSS input string
i, // current index in `input`
j, // current chunk
temp, // temporarily holds a chunk's state, for backtracking
memo, // temporarily holds `i`, when backtracking
furthest, // furthest index the parser has gone to
chunks, // chunkified input
current, // index of current chunk, in `input`
parser;
var that = this;
// This function is called after all files
// have been imported through `@import`.
var finish = function () {};
var imports = this.imports = {
paths: env && env.paths || [], // Search paths, when importing
queue: [], // Files which haven't been imported yet
files: {}, // Holds the imported parse trees
push: function (path, callback) {
var that = this;
this.queue.push(path);
//
// Import a file asynchronously
//
less.Parser.importer(path, this.paths, function (root) {
that.queue.splice(that.queue.indexOf(path), 1); // Remove the path from the queue
that.files[path] = root; // Store the root
callback(root);
if (that.queue.length === 0) { finish() } // Call `finish` if we're done importing
});
}
};
function save() { temp = chunks[j], memo = i, current = i }
function restore() { chunks[j] = temp, i = memo, current = i }
function sync() {
if (i > current) {
chunks[j] = chunks[j].slice(i - current);
current = i;
}
}
//
// Parse from a token, regexp or string, and move forward if match
//
function $(tok) {
var match, args, length, c, index, endIndex, k;
//
// Non-terminal
//
if (tok instanceof Function) {
return tok.call(parser.parsers);
//
// Terminal
//
// Either match a single character in the input,
// or match a regexp in the current chunk (chunk[j]).
//
} else if (typeof(tok) === 'string') {
match = input.charAt(i) === tok ? tok : null;
length = 1;
sync ();
// 1. We move to the next chunk, if necessary.
// 2. Set the `lastIndex` to be relative
// to the current chunk, and try to match in it.
// 3. Make sure we matched at `index`. Because we use
// the /g flag, the match could be anywhere in the
// chunk. We have to make sure it's at our previous
// index, which we stored in [2].
//
} else {
sync ();
if (match = tok.exec(chunks[j])) { // 3.
length = match[0].length;
} else {
return null;
}
}
// The match is confirmed, add the match length to `i`,
// and consume any extra white-space characters (' ' || '\n')
// which come after that. The reason for this is that LeSS's
// grammar is mostly white-space insensitive.
//
if (match) {
mem = i += length;
endIndex = i + chunks[j].length - length;
while (i < endIndex) {
c = input.charCodeAt(i);
if (! (c === 32 || c === 10 || c === 9)) { break }
i++;
}
chunks[j] = chunks[j].slice(length + (i - mem));
current = i;
if (chunks[j].length === 0 && j < chunks.length - 1) { j++ }
if(typeof(match) === 'string') {
return match;
} else {
return match.length === 1 ? match[0] : match;
}
}
}
// Same as $(), but don't change the state of the parser,
// just return the match.
function peek(tok) {
if (typeof(tok) === 'string') {
return input.charAt(i) === tok;
} else {
if (tok.test(chunks[j])) {
return true;
} else {
return false;
}
}
}
this.env = env = env || {};
// The optimization level dictates the thoroughness of the parser,
// the lower the number, the less nodes it will create in the tree.
// This could matter for debugging, or if you want to access
// the individual nodes in the tree.
this.optimization = ('optimization' in this.env) ? this.env.optimization : 1;
this.env.filename = this.env.filename || null;
//
// The Parser
//
return parser = {
imports: imports,
//
// Parse an input string into an abstract syntax tree,
// call `callback` when done.
//
parse: function (str, callback) {
var root, start, end, zone, line, lines, buff = [], c, error = null;
i = j = current = furthest = 0;
chunks = [];
input = str.replace(/\r\n/g, '\n');
// Split the input into chunks.
chunks = (function (chunks) {
var j = 0,
skip = /[^"'`\{\}\/]+/g,
comment = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g,
level = 0,
match,
chunk = chunks[0],
inString;
for (var i = 0, c, cc; i < input.length; i++) {
skip.lastIndex = i;
if (match = skip.exec(input)) {
if (match.index === i) {
i += match[0].length;
chunk.push(match[0]);
}
}
c = input.charAt(i);
comment.lastIndex = i;
if (!inString && c === '/') {
cc = input.charAt(i + 1);
if (cc === '/' || cc === '*') {
if (match = comment.exec(input)) {
if (match.index === i) {
i += match[0].length;
chunk.push(match[0]);
c = input.charAt(i);
}
}
}
}
if (c === '{' && !inString) { level ++;
chunk.push(c);
} else if (c === '}' && !inString) { level --;
chunk.push(c);
chunks[++j] = chunk = [];
} else {
if (c === '"' || c === "'" || c === '`') {
if (! inString) {
inString = c;
} else {
inString = inString === c ? false : inString;
}
}
chunk.push(c);
}
}
if (level > 0) { throw new(Error)("Missing closing '}'") }
return chunks.map(function (c) { return c.join('') });;
})([[]]);
// Start with the primary rule.
// The whole syntax tree is held under a Ruleset node,
// with the `root` property set to true, so no `{}` are
// output. The callback is called when the input is parsed.
root = new(tree.Ruleset)([], $(this.parsers.primary));
root.root = true;
root.toCSS = (function (evaluate) {
var line, lines, column;
return function (options, variables) {
var frames = [];
options = options || {};
//
// Allows setting variables with a hash, so:
//
// `{ color: new(tree.Color)('#f01') }` will become:
//
// new(tree.Rule)('@color',
// new(tree.Value)([
// new(tree.Expression)([
// new(tree.Color)('#f01')
// ])
// ])
// )
//
if (typeof(variables) === 'object' && !Array.isArray(variables)) {
variables = Object.keys(variables).map(function (k) {
var value = variables[k];
if (! (value instanceof tree.Value)) {
if (! (value instanceof tree.Expression)) {
value = new(tree.Expression)([value]);
}
value = new(tree.Value)([value]);
}
return new(tree.Rule)('@' + k, value, false, 0);
});
frames = [new(tree.Ruleset)(null, variables)];
}
try {
var css = evaluate.call(this, { frames: frames })
.toCSS([], { compress: options.compress || false });
} catch (e) {
lines = input.split('\n');
line = getLine(e.index);
for (var n = e.index, column = -1;
n >= 0 && input.charAt(n) !== '\n';
n--) { column++ }
throw {
type: e.type,
message: e.message,
filename: env.filename,
index: e.index,
line: typeof(line) === 'number' ? line + 1 : null,
callLine: e.call && (getLine(e.call) + 1),
callExtract: lines[getLine(e.call)],
stack: e.stack,
column: column,
extract: [
lines[line - 1],
lines[line],
lines[line + 1]
]
};
}
if (options.compress) {
return css.replace(/(\s)+/g, "$1");
} else {
return css;
}
function getLine(index) {
return index ? (input.slice(0, index).match(/\n/g) || "").length : null;
}
};
})(root.eval);
// If `i` is smaller than the `input.length - 1`,
// it means the parser wasn't able to parse the whole
// string, so we've got a parsing error.
//
// We try to extract a \n delimited string,
// showing the line where the parse error occured.
// We split it up into two parts (the part which parsed,
// and the part which didn't), so we can color them differently.
if (i < input.length - 1) {
i = furthest;
lines = input.split('\n');
line = (input.slice(0, i).match(/\n/g) || "").length + 1;
for (var n = i, column = -1; n >= 0 && input.charAt(n) !== '\n'; n--) { column++ }
error = {
name: "ParseError",
message: "Syntax Error on line " + line,
filename: env.filename,
line: line,
column: column,
extract: [
lines[line - 2],
lines[line - 1],
lines[line]
]
};
}
if (this.imports.queue.length > 0) {
finish = function () { callback(error, root) };
} else {
callback(error, root);
}
},
//
// Here in, the parsing rules/functions
//
// The basic structure of the syntax tree generated is as follows:
//
// Ruleset -> Rule -> Value -> Expression -> Entity
//
// Here's some LESS code:
//
// .class {
// color: #fff;
// border: 1px solid #000;
// width: @w + 4px;
// > .child {...}
// }
//
// And here's what the parse tree might look like:
//
// Ruleset (Selector '.class', [
// Rule ("color", Value ([Expression [Color #fff]]))
// Rule ("border", Value ([Expression [Dimension 1px][Keyword "solid"][Color #000]]))
// Rule ("width", Value ([Expression [Operation "+" [Variable "@w"][Dimension 4px]]]))
// Ruleset (Selector [Element '>', '.child'], [...])
// ])
//
// In general, most rules will try to parse a token with the `$()` function, and if the return
// value is truly, will return a new node, of the relevant type. Sometimes, we need to check
// first, before parsing, that's when we use `peek()`.
//
parsers: {
//
// The `primary` rule is the *entry* and *exit* point of the parser.
// The rules here can appear at any level of the parse tree.
//
// The recursive nature of the grammar is an interplay between the `block`
// rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule,
// as represented by this simplified grammar:
//
// primary → (ruleset | rule)+
// ruleset → selector+ block
// block → '{' primary '}'
//
// Only at one point is the primary rule not called from the
// block rule: at the root level.
//
primary: function () {
var node, root = [];
while ((node = $(this.mixin.definition) || $(this.rule) || $(this.ruleset) ||
$(this.mixin.call) || $(this.comment) || $(this.directive))
|| $(/^[\s\n]+/)) {
node && root.push(node);
}
return root;
},
// We create a Comment node for CSS comments `/* */`,
// but keep the LeSS comments `//` silent, by just skipping
// over them.
comment: function () {
var comment;
if (input.charAt(i) !== '/') return;
if (input.charAt(i + 1) === '/') {
return new(tree.Comment)($(/^\/\/.*/), true);
} else if (comment = $(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/)) {
return new(tree.Comment)(comment);
}
},
//
// Entities are tokens which can be found inside an Expression
//
entities: {
//
// A string, which supports escaping " and '
//
// "milky way" 'he\'s the one!'
//
quoted: function () {
var str;
if (input.charAt(i) !== '"' && input.charAt(i) !== "'") return;
if (str = $(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/)) {
return new(tree.Quoted)(str[0], str[1] || str[2]);
}
},
//
// A catch-all word, such as:
//
// black border-collapse
//
keyword: function () {
var k;
if (k = $(/^[A-Za-z-]+/)) { return new(tree.Keyword)(k) }
},
//
// A function call
//
// rgb(255, 0, 255)
//
// We also try to catch IE's `alpha()`, but let the `alpha` parser
// deal with the details.
//
// The arguments are parsed with the `entities.arguments` parser.
//
call: function () {
var name, args;
if (! (name = /^([\w-]+|%)\(/.exec(chunks[j]))) return;
name = name[1].toLowerCase();
if (name === 'url') { return null }
else { i += name.length + 1 }
if (name === 'alpha') { return $(this.alpha) }
args = $(this.entities.arguments);
if (! $(')')) return;
if (name) { return new(tree.Call)(name, args) }
},
arguments: function () {
var args = [], arg;
while (arg = $(this.expression)) {
args.push(arg);
if (! $(',')) { break }
}
return args;
},
literal: function () {
return $(this.entities.dimension) ||
$(this.entities.color) ||
$(this.entities.quoted);
},
//
// Parse url() tokens
//
// We use a specific rule for urls, because they don't really behave like
// standard function calls. The difference is that the argument doesn't have
// to be enclosed within a string, so it can't be parsed as an Expression.
//
url: function () {
var value;
if (input.charAt(i) !== 'u' || !$(/^url\(/)) return;
value = $(this.entities.quoted) || $(this.entities.variable) || $(/^[-\w%@$\/.&=:;#+?]+/) || "";
if (! $(')')) throw new(Error)("missing closing ) for url()");
return new(tree.URL)((value.value || value instanceof tree.Variable)
? value : new(tree.Anonymous)(value), imports.paths);
},
//
// A Variable entity, such as `@fink`, in
//
// width: @fink + 2px
//
// We use a different parser for variable definitions,
// see `parsers.variable`.
//
variable: function () {
var name, index = i;
if (input.charAt(i) === '@' && (name = $(/^@[\w-]+/))) {
return new(tree.Variable)(name, index);
}
},
//
// A Hexadecimal color
//
// #4F3C2F
//
// `rgb` and `hsl` colors are parsed through the `entities.call` parser.
//
color: function () {
var rgb;
if (input.charAt(i) === '#' && (rgb = $(/^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})/))) {
return new(tree.Color)(rgb[1]);
}
},
//
// A Dimension, that is, a number and a unit
//
// 0.5em 95%
//
dimension: function () {
var value, c = input.charCodeAt(i);
if ((c > 57 || c < 45) || c === 47) return;
if (value = $(/^(-?\d*\.?\d+)(px|%|em|pc|ex|in|deg|s|ms|pt|cm|mm|rad|grad|turn)?/)) {
return new(tree.Dimension)(value[1], value[2]);
}
},
//
// JavaScript code to be evaluated
//
// `window.location.href`
//
javascript: function () {
var str;
if (input.charAt(i) !== '`') { return }
if (str = $(/^`([^`]*)`/)) {
return new(tree.JavaScript)(str[1], i);
}
}
},
//
// The variable part of a variable definition. Used in the `rule` parser
//
// @fink:
//
variable: function () {
var name;
if (input.charAt(i) === '@' && (name = $(/^(@[\w-]+)\s*:/))) { return name[1] }
},
//
// A font size/line-height shorthand
//
// small/12px
//
// We need to peek first, or we'll match on keywords and dimensions
//
shorthand: function () {
var a, b;
if (! peek(/^[@\w.%-]+\/[@\w.-]+/)) return;
if ((a = $(this.entity)) && $('/') && (b = $(this.entity))) {
return new(tree.Shorthand)(a, b);
}
},
//
// Mixins
//
mixin: {
//
// A Mixin call, with an optional argument list
//
// #mixins > .square(#fff);
// .rounded(4px, black);
// .button;
//
// The `while` loop is there because mixins can be
// namespaced, but we only support the child and descendant
// selector for now.
//
call: function () {
var elements = [], e, c, args, index = i, s = input.charAt(i);
if (s !== '.' && s !== '#') { return }
while (e = $(/^[#.][\w-]+/)) {
elements.push(new(tree.Element)(c, e));
c = $('>');
}
$('(') && (args = $(this.entities.arguments)) && $(')');
if (elements.length > 0 && ($(';') || peek('}'))) {
return new(tree.mixin.Call)(elements, args, index);
}
},
//
// A Mixin definition, with a list of parameters
//
// .rounded (@radius: 2px, @color) {
// ...
// }
//
// Until we have a finer grained state-machine, we have to
// do a look-ahead, to make sure we don't have a mixin call.
// See the `rule` function for more information.
//
// We start by matching `.rounded (`, and then proceed on to
// the argument list, which has optional default values.
// We store the parameters in `params`, with a `value` key,
// if there is a value, such as in the case of `@radius`.
//
// Once we've got our params list, and a closing `)`, we parse
// the `{...}` block.
//
definition: function () {
var name, params = [], match, ruleset, param, value;
if ((input.charAt(i) !== '.' && input.charAt(i) !== '#') ||
peek(/^[^{]*(;|})/)) return;
if (match = $(/^([#.][\w-]+)\s*\(/)) {
name = match[1];
while (param = $(this.entities.variable) || $(this.entities.literal)
|| $(this.entities.keyword)) {
// Variable
if (param instanceof tree.Variable) {
if ($(':')) {
if (value = $(this.expression)) {
params.push({ name: param.name, value: value });
} else {
throw new(Error)("Expected value");
}
} else {
params.push({ name: param.name });
}
} else {
params.push({ value: param });
}
if (! $(',')) { break }
}
if (! $(')')) throw new(Error)("Expected )");
ruleset = $(this.block);
if (ruleset) {
return new(tree.mixin.Definition)(name, params, ruleset);
}
}
}
},
//
// Entities are the smallest recognized token,
// and can be found inside a rule's value.
//
entity: function () {
return $(this.entities.literal) || $(this.entities.variable) || $(this.entities.url) ||
$(this.entities.call) || $(this.entities.keyword) || $(this.entities.javascript);
},
//
// A Rule terminator. Note that we use `peek()` to check for '}',
// because the `block` rule will be expecting it, but we still need to make sure
// it's there, if ';' was ommitted.
//
end: function () {
return $(';') || peek('}');
},
//
// IE's alpha function
//
// alpha(opacity=88)
//
alpha: function () {
var value;
if (! $(/^opacity=/i)) return;
if (value = $(/^\d+/) || $(this.entities.variable)) {
if (! $(')')) throw new(Error)("missing closing ) for alpha()");
return new(tree.Alpha)(value);
}
},
//
// A Selector Element
//
// div
// + h1
// #socks
// input[type="text"]
//
// Elements are the building blocks for Selectors,
// they are made out of a `Combinator` (see combinator rule),
// and an element name, such as a tag a class, or `*`.
//
element: function () {
var e, t;
c = $(this.combinator);
e = $(/^[.#:]?[\w-]+/) || $('*') || $(this.attribute) || $(/^\([^)@]+\)/);
if (e) { return new(tree.Element)(c, e) }
},
//
// Combinators combine elements together, in a Selector.
//
// Because our parser isn't white-space sensitive, special care
// has to be taken, when parsing the descendant combinator, ` `,
// as it's an empty space. We have to check the previous character
// in the input, to see if it's a ` ` character. More info on how
// we deal with this in *combinator.js*.
//
combinator: function () {
var match, c = input.charAt(i);
if (c === '>' || c === '&' || c === '+' || c === '~') {
i++;
while (input.charAt(i) === ' ') { i++ }
return new(tree.Combinator)(c);
} else if (c === ':' && input.charAt(i + 1) === ':') {
i += 2;
while (input.charAt(i) === ' ') { i++ }
return new(tree.Combinator)('::');
} else if (input.charAt(i - 1) === ' ') {
return new(tree.Combinator)(" ");
} else {
return new(tree.Combinator)(null);
}
},
//
// A CSS Selector
//
// .class > div + h1
// li a:hover
//
// Selectors are made out of one or more Elements, see above.
//
selector: function () {
var sel, e, elements = [], c, match;
while (e = $(this.element)) {
c = input.charAt(i);
elements.push(e)
if (c === '{' || c === '}' || c === ';' || c === ',') { break }
}
if (elements.length > 0) { return new(tree.Selector)(elements) }
},
tag: function () {
return $(/^[a-zA-Z][a-zA-Z-]*[0-9]?/) || $('*');
},
attribute: function () {
var attr = '', key, val, op;
if (! $('[')) return;
if (key = $(/^[a-zA-Z-]+/) || $(this.entities.quoted)) {
if ((op = $(/^[|~*$^]?=/)) &&
(val = $(this.entities.quoted) || $(/^[\w-]+/))) {
attr = [key, op, val.toCSS ? val.toCSS() : val].join('');
} else { attr = key }
}
if (! $(']')) return;
if (attr) { return "[" + attr + "]" }
},
//
// The `block` rule is used by `ruleset` and `mixin.definition`.
// It's a wrapper around the `primary` rule, with added `{}`.
//
block: function () {
var content;
if ($('{') && (content = $(this.primary)) && $('}')) {
return content;
}
},
//
// div, .class, body > p {...}
//
ruleset: function () {
var selectors = [], s, rules, match;
save();
if (match = /^([.#: \w-]+)[\s\n]*\{/.exec(chunks[j])) {
i += match[0].length - 1;
selectors = [new(tree.Selector)([new(tree.Element)(null, match[1])])];
} else {
while (s = $(this.selector)) {
selectors.push(s);
if (! $(',')) { break }
}
if (s) $(this.comment);
}
if (selectors.length > 0 && (rules = $(this.block))) {
return new(tree.Ruleset)(selectors, rules);
} else {
// Backtrack
furthest = i;
restore();
}
},
rule: function () {
var value, c = input.charAt(i), important;
save();
if (c === '.' || c === '#' || c === '&') { return }
if (name = $(this.variable) || $(this.property)) {
if ((name.charAt(0) != '@') && (match = /^([^@+\/'"*`(;{}-]*);/.exec(chunks[j]))) {
i += match[0].length - 1;
value = new(tree.Anonymous)(match[1]);
} else if (name === "font") {
value = $(this.font);
} else {
value = $(this.value);
}
important = $(this.important);
if (value && $(this.end)) {
return new(tree.Rule)(name, value, important, memo);
} else {
furthest = i;
restore();
}
}
},
//
// An @import directive
//
// @import "lib";
//
// Depending on our environemnt, importing is done differently:
// In the browser, it's an XHR request, in Node, it would be a
// file-system operation. The function used for importing is
// stored in `import`, which we pass to the Import constructor.
//
"import": function () {
var path;
if ($(/^@import\s+/) &&
(path = $(this.entities.quoted) || $(this.entities.url)) &&
$(';')) {
return new(tree.Import)(path, imports);
}
},
//
// A CSS Directive
//
// @charset "utf-8";
//
directive: function () {
var name, value, rules, types;
if (input.charAt(i) !== '@') return;
if (value = $(this['import'])) {
return value;
} else if (name = $(/^@media|@page/)) {
types = $(/^[^{]+/).trim();
if (rules = $(this.block)) {
return new(tree.Directive)(name + " " + types, rules);
}
} else if (name = $(/^@[-a-z]+/)) {
if (name === '@font-face') {
if (rules = $(this.block)) {
return new(tree.Directive)(name, rules);
}
} else if ((value = $(this.entity)) && $(';')) {
return new(tree.Directive)(name, value);
}
}
},
font: function () {
var value = [], expression = [], weight, shorthand, font, e;
while (e = $(this.shorthand) || $(this.entity)) {
expression.push(e);
}
value.push(new(tree.Expression)(expression));
if ($(',')) {
while (e = $(this.expression)) {
value.push(e);
if (! $(',')) { break }
}
}
return new(tree.Value)(value);
},
//
// A Value is a comma-delimited list of Expressions
//
// font-family: Baskerville, Georgia, serif;
//
// In a Rule, a Value represents everything after the `:`,
// and before the `;`.
//
value: function () {
var e, expressions = [], important;
while (e = $(this.expression)) {
expressions.push(e);
if (! $(',')) { break }
}
if (expressions.length > 0) {
return new(tree.Value)(expressions);
}
},
important: function () {
if (input.charAt(i) === '!') {
return $(/^! *important/);
}
},
sub: function () {
var e;
if ($('(') && (e = $(this.expression)) && $(')')) {
return e;
}
},
multiplication: function () {
var m, a, op, operation;
if (m = $(this.operand)) {
while ((op = ($('/') || $('*'))) && (a = $(this.operand))) {
operation = new(tree.Operation)(op, [operation || m, a]);
}
return operation || m;
}
},
addition: function () {
var m, a, op, operation;
if (m = $(this.multiplication)) {
while ((op = $(/^[-+]\s+/) || (input.charAt(i - 1) != ' ' && ($('+') || $('-')))) &&
(a = $(this.multiplication))) {
operation = new(tree.Operation)(op, [operation || m, a]);
}
return operation || m;
}
},
//
// An operand is anything that can be part of an operation,
// such as a Color, or a Variable
//
operand: function () {
return $(this.sub) || $(this.entities.dimension) ||
$(this.entities.color) || $(this.entities.variable) ||
$(this.entities.call);
},
//
// Expressions either represent mathematical operations,
// or white-space delimited Entities.
//
// 1px solid black
// @var * 2
//
expression: function () {
var e, delim, entities = [], d;
while (e = $(this.addition) || $(this.entity)) {
entities.push(e);
}
if (entities.length > 0) {
return new(tree.Expression)(entities);
}
},
property: function () {
var name;
if (name = $(/^(\*?-?[-a-z_0-9]+)\s*:/)) {
return name[1];
}
}
}
};
};
if (typeof(window) !== 'undefined') {
//
// Used by `@import` directives
//
less.Parser.importer = function (path, paths, callback) {
if (path.charAt(0) !== '/' && paths.length > 0) {
path = paths[0] + path;
}
// We pass `true` as 3rd argument, to force the reload of the import.
// This is so we can get the syntax tree as opposed to just the CSS output,
// as we need this to evaluate the current stylesheet.
loadStyleSheet({ href: path, title: path }, callback, true);
};
}
(function (tree) {
tree.functions = {
rgb: function (r, g, b) {
return this.rgba(r, g, b, 1.0);
},
rgba: function (r, g, b, a) {
var rgb = [r, g, b].map(function (c) { return number(c) }),
a = number(a);
return new(tree.Color)(rgb, a);
},
hsl: function (h, s, l) {
return this.hsla(h, s, l, 1.0);
},
hsla: function (h, s, l, a) {
h = (number(h) % 360) / 360;
s = number(s); l = number(l); a = number(a);
var m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s;
var m1 = l * 2 - m2;
return this.rgba(hue(h + 1/3) * 255,
hue(h) * 255,
hue(h - 1/3) * 255,
a);
function hue(h) {
h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
if (h * 6 < 1) return m1 + (m2 - m1) * h * 6;
else if (h * 2 < 1) return m2;
else if (h * 3 < 2) return m1 + (m2 - m1) * (2/3 - h) * 6;
else return m1;
}
},
hue: function (color) {
return new(tree.Dimension)(Math.round(color.toHSL().h));
},
saturation: function (color) {
return new(tree.Dimension)(Math.round(color.toHSL().s * 100), '%');
},
lightness: function (color) {
return new(tree.Dimension)(Math.round(color.toHSL().l * 100), '%');
},
alpha: function (color) {
return new(tree.Dimension)(color.toHSL().a);
},
saturate: function (color, amount) {
var hsl = color.toHSL();
hsl.s += amount.value / 100;
hsl.s = clamp(hsl.s);
return hsla(hsl);
},
desaturate: function (color, amount) {
var hsl = color.toHSL();
hsl.s -= amount.value / 100;
hsl.s = clamp(hsl.s);
return hsla(hsl);
},
lighten: function (color, amount) {
var hsl = color.toHSL();
hsl.l += amount.value / 100;
hsl.l = clamp(hsl.l);
return hsla(hsl);
},
darken: function (color, amount) {
var hsl = color.toHSL();
hsl.l -= amount.value / 100;
hsl.l = clamp(hsl.l);
return hsla(hsl);
},
spin: function (color, amount) {
var hsl = color.toHSL();
var hue = (hsl.h + amount.value) % 360;
hsl.h = hue < 0 ? 360 + hue : hue;
return hsla(hsl);
},
greyscale: function (color) {
return this.desaturate(color, new(tree.Dimension)(100));
},
e: function (str) {
return new(tree.Anonymous)(str instanceof tree.JavaScript ? str.evaluated : str);
},
'%': function (quoted /* arg, arg, ...*/) {
var args = Array.prototype.slice.call(arguments, 1),
str = quoted.value;
for (var i = 0; i < args.length; i++) {
str = str.replace(/%s/, args[i].value)
.replace(/%[da]/, args[i].toCSS());
}
str = str.replace(/%%/g, '%');
return new(tree.Quoted)('"' + str + '"', str);
}
};
function hsla(hsla) {
return tree.functions.hsla(hsla.h, hsla.s, hsla.l, hsla.a);
}
function number(n) {
if (n instanceof tree.Dimension) {
return parseFloat(n.unit == '%' ? n.value / 100 : n.value);
} else if (typeof(n) === 'number') {
return n;
} else {
throw {
error: "RuntimeError",
message: "color functions take numbers as parameters"
};
}
}
function clamp(val) {
return Math.min(1, Math.max(0, val));
}
})(require('less/tree'));
(function (tree) {
tree.Alpha = function (val) {
this.value = val;
};
tree.Alpha.prototype = {
toCSS: function () {
return "alpha(opacity=" +
(this.value.toCSS ? this.value.toCSS() : this.value) + ")";
},
eval: function () { return this }
};
})(require('less/tree'));
(function (tree) {
tree.Anonymous = function (string) {
this.value = string.value || string;
};
tree.Anonymous.prototype = {
toCSS: function () {
return this.value;
},
eval: function () { return this }
};
})(require('less/tree'));
(function (tree) {
//
// A function call node.
//
tree.Call = function (name, args) {
this.name = name;
this.args = args;
};
tree.Call.prototype = {
//
// When evaluating a function call,
// we either find the function in `tree.functions` [1],
// in which case we call it, passing the evaluated arguments,
// or we simply print it out as it appeared originally [2].
//
// The *functions.js* file contains the built-in functions.
//
// The reason why we evaluate the arguments, is in the case where
// we try to pass a variable to a function, like: `saturate(@color)`.
// The function should receive the value, not the variable.
//
eval: function (env) {
var args = this.args.map(function (a) { return a.eval(env) });
if (this.name in tree.functions) { // 1.
return tree.functions[this.name].apply(tree.functions, args);
} else { // 2.
return new(tree.Anonymous)(this.name +
"(" + args.map(function (a) { return a.toCSS() }).join(', ') + ")");
}
},
toCSS: function (env) {
return this.eval(env).toCSS();
}
};
})(require('less/tree'));
(function (tree) {
//
// RGB Colors - #ff0014, #eee
//
tree.Color = function (rgb, a) {
//
// The end goal here, is to parse the arguments
// into an integer triplet, such as `128, 255, 0`
//
// This facilitates operations and conversions.
//
if (Array.isArray(rgb)) {
this.rgb = rgb;
} else if (rgb.length == 6) {
this.rgb = rgb.match(/.{2}/g).map(function (c) {
return parseInt(c, 16);
});
} else {
this.rgb = rgb.split('').map(function (c) {
return parseInt(c + c, 16);
});
}
this.alpha = typeof(a) === 'number' ? a : 1;
};
tree.Color.prototype = {
eval: function () { return this },
//
// If we have some transparency, the only way to represent it
// is via `rgba`. Otherwise, we use the hex representation,
// which has better compatibility with older browsers.
// Values are capped between `0` and `255`, rounded and zero-padded.
//
toCSS: function () {
if (this.alpha < 1.0) {
return "rgba(" + this.rgb.map(function (c) {
return Math.round(c);
}).concat(this.alpha).join(', ') + ")";
} else {
return '#' + this.rgb.map(function (i) {
i = Math.round(i);
i = (i > 255 ? 255 : (i < 0 ? 0 : i)).toString(16);
return i.length === 1 ? '0' + i : i;
}).join('');
}
},
//
// Operations have to be done per-channel, if not,
// channels will spill onto each other. Once we have
// our result, in the form of an integer triplet,
// we create a new Color node to hold the result.
//
operate: function (op, other) {
var result = [];
if (! (other instanceof tree.Color)) {
other = other.toColor();
}
for (var c = 0; c < 3; c++) {
result[c] = tree.operate(op, this.rgb[c], other.rgb[c]);
}
return new(tree.Color)(result);
},
toHSL: function () {
var r = this.rgb[0] / 255,
g = this.rgb[1] / 255,
b = this.rgb[2] / 255,
a = this.alpha;
var max = Math.max(r, g, b), min = Math.min(r, g, b);
var h, s, l = (max + min) / 2, d = max - min;
if (max === min) {
h = s = 0;
} else {
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
switch (max) {
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
case g: h = (b - r) / d + 2; break;
case b: h = (r - g) / d + 4; break;
}
h /= 6;
}
return { h: h * 360, s: s, l: l, a: a };
}
};
})(require('less/tree'));
(function (tree) {
tree.Comment = function (value, silent) {
this.value = value;
this.silent = !!silent;
};
tree.Comment.prototype = {
toCSS: function (env) {
return env.compress ? '' : this.value;
},
eval: function () { return this }
};
})(require('less/tree'));
(function (tree) {
//
// A number with a unit
//
tree.Dimension = function (value, unit) {
this.value = parseFloat(value);
this.unit = unit || null;
};
tree.Dimension.prototype = {
eval: function () { return this },
toColor: function () {
return new(tree.Color)([this.value, this.value, this.value]);
},
toCSS: function () {
var css = this.value + this.unit;
return css;
},
// In an operation between two Dimensions,
// we default to the first Dimension's unit,
// so `1px + 2em` will yield `3px`.
// In the future, we could implement some unit
// conversions such that `100cm + 10mm` would yield
// `101cm`.
operate: function (op, other) {
return new(tree.Dimension)
(tree.operate(op, this.value, other.value),
this.unit || other.unit);
}
};
})(require('less/tree'));
(function (tree) {
tree.Directive = function (name, value) {
this.name = name;
if (Array.isArray(value)) {
this.ruleset = new(tree.Ruleset)([], value);
} else {
this.value = value;
}
};
tree.Directive.prototype = {
toCSS: function (ctx, env) {
if (this.ruleset) {
this.ruleset.root = true;
return this.name + (env.compress ? '{' : ' {\n ') +
this.ruleset.toCSS(ctx, env).trim().replace(/\n/g, '\n ') +
(env.compress ? '}': '\n}\n');
} else {
return this.name + ' ' + this.value.toCSS() + ';\n';
}
},
eval: function (env) {
env.frames.unshift(this);
this.ruleset = this.ruleset && this.ruleset.eval(env);
env.frames.shift();
return this;
},
variable: function (name) { return tree.Ruleset.prototype.variable.call(this.ruleset, name) },
find: function () { return tree.Ruleset.prototype.find.apply(this.ruleset, arguments) },
rulesets: function () { return tree.Ruleset.prototype.rulesets.apply(this.ruleset) }
};
})(require('less/tree'));
(function (tree) {
tree.Element = function (combinator, value) {
this.combinator = combinator instanceof tree.Combinator ?
combinator : new(tree.Combinator)(combinator);
this.value = value.trim();
};
tree.Element.prototype.toCSS = function (env) {
return this.combinator.toCSS(env || {}) + this.value;
};
tree.Combinator = function (value) {
if (value === ' ') {
this.value = ' ';
} else {
this.value = value ? value.trim() : "";
}
};
tree.Combinator.prototype.toCSS = function (env) {
return {
'' : '',
' ' : ' ',
'&' : '',
':' : ' :',
'::': '::',
'+' : env.compress ? '+' : ' + ',
'~' : env.compress ? '~' : ' ~ ',
'>' : env.compress ? '>' : ' > '
}[this.value];
};
})(require('less/tree'));
(function (tree) {
tree.Expression = function (value) { this.value = value };
tree.Expression.prototype = {
eval: function (env) {
if (this.value.length > 1) {
return new(tree.Expression)(this.value.map(function (e) {
return e.eval(env);
}));
} else {
return this.value[0].eval(env);
}
},
toCSS: function (env) {
return this.value.map(function (e) {
return e.toCSS(env);
}).join(' ');
}
};
})(require('less/tree'));
(function (tree) {
//
// CSS @import node
//
// The general strategy here is that we don't want to wait
// for the parsing to be completed, before we start importing
// the file. That's because in the context of a browser,
// most of the time will be spent waiting for the server to respond.
//
// On creation, we push the import path to our import queue, though
// `import,push`, we also pass it a callback, which it'll call once
// the file has been fetched, and parsed.
//
tree.Import = function (path, imports) {
var that = this;
this._path = path;
// The '.less' extension is optional
if (path instanceof tree.Quoted) {
this.path = /\.(le?|c)ss$/.test(path.value) ? path.value : path.value + '.less';
} else {
this.path = path.value.value || path.value;
}
this.css = /css$/.test(this.path);
// Only pre-compile .less files
if (! this.css) {
imports.push(this.path, function (root) {
if (! root) {
throw new(Error)("Error parsing " + that.path);
}
that.root = root;
});
}
};
//
// The actual import node doesn't return anything, when converted to CSS.
// The reason is that it's used at the evaluation stage, so that the rules
// it imports can be treated like any other rules.
//
// In `eval`, we make sure all Import nodes get evaluated, recursively, so
// we end up with a flat structure, which can easily be imported in the parent
// ruleset.
//
tree.Import.prototype = {
toCSS: function () {
if (this.css) {
return "@import " + this._path.toCSS() + ';\n';
} else {
return "";
}
},
eval: function (env) {
var ruleset;
if (this.css) {
return this;
} else {
ruleset = new(tree.Ruleset)(null, this.root.rules.slice(0));
for (var i = 0; i < ruleset.rules.length; i++) {
if (ruleset.rules[i] instanceof tree.Import) {
Array.prototype
.splice
.apply(ruleset.rules,
[i, 1].concat(ruleset.rules[i].eval(env)));
}
}
return ruleset.rules;
}
}
};
})(require('less/tree'));
(function (tree) {
tree.JavaScript = function (string, index) {
this.expression = string;
this.index = index;
};
tree.JavaScript.prototype = {
toCSS: function () {
return JSON.stringify(this.evaluated);
},
eval: function (env) {
var result,
expression = new(Function)('return (' + this.expression + ')'),
context = {};
for (var k in env.frames[0].variables()) {
context[k.slice(1)] = {
value: env.frames[0].variables()[k].value,
toJS: function () {
return this.value.eval(env).toCSS();
}
};
}
try {
this.evaluated = expression.call(context);
} catch (e) {
throw { message: "JavaScript evaluation error: '" + e.name + ': ' + e.message + "'" ,
index: this.index };
}
return this;
}
};
})(require('less/tree'));
(function (tree) {
tree.Keyword = function (value) { this.value = value };
tree.Keyword.prototype = {
eval: function () { return this },
toCSS: function () { return this.value }
};
})(require('less/tree'));
(function (tree) {
tree.mixin = {};
tree.mixin.Call = function (elements, args, index) {
this.selector = new(tree.Selector)(elements);
this.arguments = args;
this.index = index;
};
tree.mixin.Call.prototype = {
eval: function (env) {
var mixins, rules = [], match = false;
for (var i = 0; i < env.frames.length; i++) {
if ((mixins = env.frames[i].find(this.selector)).length > 0) {
for (var m = 0; m < mixins.length; m++) {
if (mixins[m].match(this.arguments, env)) {
try {
Array.prototype.push.apply(
rules, mixins[m].eval(env, this.arguments).rules);
match = true;
} catch (e) {
throw { message: e.message, index: e.index, stack: e.stack, call: this.index };
}
}
}
if (match) {
return rules;
} else {
throw { message: 'No matching definition was found for `' +
this.selector.toCSS().trim() + '(' +
this.arguments.map(function (a) {
return a.toCSS();
}).join(', ') + ")`",
index: this.index };
}
}
}
throw { message: this.selector.toCSS().trim() + " is undefined",
index: this.index };
}
};
tree.mixin.Definition = function (name, params, rules) {
this.name = name;
this.selectors = [new(tree.Selector)([new(tree.Element)(null, name)])];
this.params = params;
this.arity = params.length;
this.rules = rules;
this._lookups = {};
this.required = params.reduce(function (count, p) {
if (p.name && !p.value) { return count + 1 }
else { return count }
}, 0);
this.parent = tree.Ruleset.prototype;
this.frames = [];
};
tree.mixin.Definition.prototype = {
toCSS: function () { return "" },
variable: function (name) { return this.parent.variable.call(this, name) },
variables: function () { return this.parent.variables.call(this) },
find: function () { return this.parent.find.apply(this, arguments) },
rulesets: function () { return this.parent.rulesets.apply(this) },
eval: function (env, args) {
var frame = new(tree.Ruleset)(null, []), context;
for (var i = 0, val; i < this.params.length; i++) {
if (this.params[i].name) {
if (val = (args && args[i]) || this.params[i].value) {
frame.rules.unshift(new(tree.Rule)(this.params[i].name, val.eval(env)));
} else {
throw { message: "wrong number of arguments for " + this.name +
' (' + args.length + ' for ' + this.arity + ')' };
}
}
}
return new(tree.Ruleset)(null, this.rules.slice(0)).eval({
frames: [this, frame].concat(this.frames, env.frames)
});
},
match: function (args, env) {
var argsLength = (args && args.length) || 0, len;
if (argsLength < this.required) { return false }
len = Math.min(argsLength, this.arity);
for (var i = 0; i < len; i++) {
if (!this.params[i].name) {
if (args[i].eval(env).toCSS() != this.params[i].value.eval(env).toCSS()) {
return false;
}
}
}
return true;
}
};
})(require('less/tree'));
(function (tree) {
tree.Operation = function (op, operands) {
this.op = op.trim();
this.operands = operands;
};
tree.Operation.prototype.eval = function (env) {
var a = this.operands[0].eval(env),
b = this.operands[1].eval(env),
temp;
if (a instanceof tree.Dimension && b instanceof tree.Color) {
if (this.op === '*' || this.op === '+') {
temp = b, b = a, a = temp;
} else {
throw { name: "OperationError",
message: "Can't substract or divide a color from a number" };
}
}
return a.operate(this.op, b);
};
tree.operate = function (op, a, b) {
switch (op) {
case '+': return a + b;
case '-': return a - b;
case '*': return a * b;
case '/': return a / b;
}
};
})(require('less/tree'));
(function (tree) {
tree.Quoted = function (str, content) {
this.value = content || '';
this.quote = str.charAt(0);
};
tree.Quoted.prototype = {
toCSS: function () {
return this.quote + this.value + this.quote;
},
eval: function () {
return this;
}
};
})(require('less/tree'));
(function (tree) {
tree.Rule = function (name, value, important, index) {
this.name = name;
this.value = (value instanceof tree.Value) ? value : new(tree.Value)([value]);
this.important = important ? ' ' + important.trim() : '';
this.index = index;
if (name.charAt(0) === '@') {
this.variable = true;
} else { this.variable = false }
};
tree.Rule.prototype.toCSS = function (env) {
if (this.variable) { return "" }
else {
return this.name + (env.compress ? ':' : ': ') +
this.value.toCSS(env) +
this.important + ";";
}
};
tree.Rule.prototype.eval = function (context) {
return new(tree.Rule)(this.name, this.value.eval(context), this.important, this.index);
};
tree.Shorthand = function (a, b) {
this.a = a;
this.b = b;
};
tree.Shorthand.prototype = {
toCSS: function (env) {
return this.a.toCSS(env) + "/" + this.b.toCSS(env);
},
eval: function () { return this }
};
})(require('less/tree'));
(function (tree) {
tree.Ruleset = function (selectors, rules) {
this.selectors = selectors;
this.rules = rules;
this._lookups = {};
};
tree.Ruleset.prototype = {
eval: function (env) {
var ruleset = new(tree.Ruleset)(this.selectors, this.rules.slice(0));
ruleset.root = this.root;
// push the current ruleset to the frames stack
env.frames.unshift(ruleset);
// Evaluate imports
if (ruleset.root) {
for (var i = 0; i < ruleset.rules.length; i++) {
if (ruleset.rules[i] instanceof tree.Import) {
Array.prototype.splice
.apply(ruleset.rules, [i, 1].concat(ruleset.rules[i].eval(env)));
}
}
}
// Store the frames around mixin definitions,
// so they can be evaluated like closures when the time comes.
for (var i = 0; i < ruleset.rules.length; i++) {
if (ruleset.rules[i] instanceof tree.mixin.Definition) {
ruleset.rules[i].frames = env.frames.slice(0);
}
}
// Evaluate mixin calls.
for (var i = 0; i < ruleset.rules.length; i++) {
if (ruleset.rules[i] instanceof tree.mixin.Call) {
Array.prototype.splice
.apply(ruleset.rules, [i, 1].concat(ruleset.rules[i].eval(env)));
}
}
// Evaluate everything else
for (var i = 0, rule; i < ruleset.rules.length; i++) {
rule = ruleset.rules[i];
if (! (rule instanceof tree.mixin.Definition)) {
ruleset.rules[i] = rule.eval ? rule.eval(env) : rule;
}
}
// Pop the stack
env.frames.shift();
return ruleset;
},
match: function (args) {
return !args || args.length === 0;
},
variables: function () {
if (this._variables) { return this._variables }
else {
return this._variables = this.rules.reduce(function (hash, r) {
if (r instanceof tree.Rule && r.variable === true) {
hash[r.name] = r;
}
return hash;
}, {});
}
},
variable: function (name) {
return this.variables()[name];
},
rulesets: function () {
if (this._rulesets) { return this._rulesets }
else {
return this._rulesets = this.rules.filter(function (r) {
return (r instanceof tree.Ruleset) || (r instanceof tree.mixin.Definition);
});
}
},
find: function (selector, self) {
self = self || this;
var rules = [], rule, match,
key = selector.toCSS();
if (key in this._lookups) { return this._lookups[key] }
this.rulesets().forEach(function (rule) {
if (rule !== self) {
for (var j = 0; j < rule.selectors.length; j++) {
if (match = selector.match(rule.selectors[j])) {
if (selector.elements.length > 1) {
Array.prototype.push.apply(rules, rule.find(
new(tree.Selector)(selector.elements.slice(1)), self));
} else {
rules.push(rule);
}
break;
}
}
}
});
return this._lookups[key] = rules;
},
//
// Entry point for code generation
//
// `context` holds an array of arrays.
//
toCSS: function (context, env) {
var css = [], // The CSS output
rules = [], // node.Rule instances
rulesets = [], // node.Ruleset instances
paths = [], // Current selectors
selector, // The fully rendered selector
rule;
if (! this.root) {
if (context.length === 0) {
paths = this.selectors.map(function (s) { return [s] });
} else {
for (var s = 0; s < this.selectors.length; s++) {
for (var c = 0; c < context.length; c++) {
paths.push(context[c].concat([this.selectors[s]]));
}
}
}
}
// Compile rules and rulesets
for (var i = 0; i < this.rules.length; i++) {
rule = this.rules[i];
if (rule.rules || (rule instanceof tree.Directive)) {
rulesets.push(rule.toCSS(paths, env));
} else if (rule instanceof tree.Comment) {
if (!rule.silent) {
if (this.root) {
rulesets.push(rule.toCSS(env));
} else {
rules.push(rule.toCSS(env));
}
}
} else {
if (rule.toCSS && !rule.variable) {
rules.push(rule.toCSS(env));
} else if (rule.value && !rule.variable) {
rules.push(rule.value.toString());
}
}
}
rulesets = rulesets.join('');
// If this is the root node, we don't render
// a selector, or {}.
// Otherwise, only output if this ruleset has rules.
if (this.root) {
css.push(rules.join(env.compress ? '' : '\n'));
} else {
if (rules.length > 0) {
selector = paths.map(function (p) {
return p.map(function (s) {
return s.toCSS(env);
}).join('').trim();
}).join(env.compress ? ',' : (paths.length > 3 ? ',\n' : ', '));
css.push(selector,
(env.compress ? '{' : ' {\n ') +
rules.join(env.compress ? '' : '\n ') +
(env.compress ? '}' : '\n}\n'));
}
}
css.push(rulesets);
return css.join('') + (env.compress ? '\n' : '');
}
};
})(require('less/tree'));
(function (tree) {
tree.Selector = function (elements) {
this.elements = elements;
if (this.elements[0].combinator.value === "") {
this.elements[0].combinator.value = ' ';
}
};
tree.Selector.prototype.match = function (other) {
if (this.elements[0].value === other.elements[0].value) {
return true;
} else {
return false;
}
};
tree.Selector.prototype.toCSS = function (env) {
if (this._css) { return this._css }
return this._css = this.elements.map(function (e) {
if (typeof(e) === 'string') {
return ' ' + e.trim();
} else {
return e.toCSS(env);
}
}).join('');
};
})(require('less/tree'));
(function (tree) {
tree.URL = function (val, paths) {
// Add the base path if the URL is relative and we are in the browser
if (!/^(?:http:\/)?\//.test(val.value) && paths.length > 0 && typeof(window) !== 'undefined') {
val.value = [paths[0], val.value].join('/').replace('//', '/');
}
this.value = val;
this.paths = paths;
};
tree.URL.prototype = {
toCSS: function () {
return "url(" + this.value.toCSS() + ")";
},
eval: function (ctx) {
return new(tree.URL)(this.value.eval(ctx), this.paths);
}
};
})(require('less/tree'));
(function (tree) {
tree.Value = function (value) {
this.value = value;
this.is = 'value';
};
tree.Value.prototype = {
eval: function (env) {
if (this.value.length === 1) {
return this.value[0].eval(env);
} else {
return new(tree.Value)(this.value.map(function (v) {
return v.eval(env);
}));
}
},
toCSS: function (env) {
return this.value.map(function (e) {
return e.toCSS(env);
}).join(env.compress ? ',' : ', ');
}
};
})(require('less/tree'));
(function (tree) {
tree.Variable = function (name, index) { this.name = name, this.index = index };
tree.Variable.prototype = {
eval: function (env) {
var variable, v, name = this.name;
if (variable = tree.find(env.frames, function (frame) {
if (v = frame.variable(name)) {
return v.value.eval(env);
}
})) { return variable }
else {
throw { message: "variable " + this.name + " is undefined",
index: this.index };
}
}
};
})(require('less/tree'));
require('less/tree').find = function (obj, fun) {
for (var i = 0, r; i < obj.length; i++) {
if (r = fun.call(obj, obj[i])) { return r }
}
return null;
};
//
// browser.js - client-side engine
//
var isFileProtocol = (location.protocol === 'file:' ||
location.protocol === 'chrome:' ||
location.protocol === 'resource:');
less.env = 'production';
// Load styles asynchronously (default: false)
//
// This is set to `false` by default, so that the body
// doesn't start loading before the stylesheets are parsed.
// Setting this to `true` can result in flickering.
//
less.async = false;
// Interval between watch polls
less.poll = less.poll || (isFileProtocol ? 1000 : 1500);
//
// Watch mode
//
less.watch = function () { return this.watchMode = true };
less.unwatch = function () { return this.watchMode = false };
if (less.env === 'development') {
less.optimization = 0;
if (/!watch/.test(location.hash)) {
less.watch();
}
less.watchTimer = setInterval(function () {
if (less.watchMode) {
loadStyleSheets(function (root, sheet, env) {
if (root) {
createCSS(root.toCSS(), sheet, env.lastModified);
}
});
}
}, less.poll);
} else {
less.optimization = 3;
}
var cache;
try {
cache = (typeof(window.localStorage) === 'undefined') ? null : window.localStorage;
} catch (_) {
cache = null;
}
//
// Get all <link> tags with the 'rel' attribute set to "stylesheet/less"
//
var links = document.getElementsByTagName('link');
var typePattern = /^text\/(x-)?less$/;
less.sheets = [];
for (var i = 0; i < links.length; i++) {
if (links[i].rel === 'stylesheet/less' || (links[i].rel.match(/stylesheet/) &&
(links[i].type.match(typePattern)))) {
less.sheets.push(links[i]);
}
}
less.refresh = function (reload) {
var startTime = endTime = new(Date);
loadStyleSheets(function (root, sheet, env) {
if (env.local) {
log("loading " + sheet.href + " from cache.");
} else {
log("parsed " + sheet.href + " successfully.");
createCSS(root.toCSS(), sheet, env.lastModified);
}
log("css for " + sheet.href + " generated in " + (new(Date) - endTime) + 'ms');
(env.remaining === 0) && log("css generated in " + (new(Date) - startTime) + 'ms');
endTime = new(Date);
}, reload);
loadStyles();
};
less.refreshStyles = loadStyles;
less.refresh(less.env === 'development');
function loadStyles() {
var styles = document.getElementsByTagName('style');
for (var i = 0; i < styles.length; i++) {
if (styles[i].type.match(typePattern)) {
new(less.Parser)().parse(styles[i].innerHTML || '', function (e, tree) {
styles[i].type = 'text/css';
styles[i].innerHTML = tree.toCSS();
});
}
}
}
function loadStyleSheets(callback, reload) {
for (var i = 0; i < less.sheets.length; i++) {
loadStyleSheet(less.sheets[i], callback, reload, less.sheets.length - (i + 1));
}
}
function loadStyleSheet(sheet, callback, reload, remaining) {
var href = sheet.href.replace(/\?.*$/, '');
var css = cache && cache.getItem(href);
var timestamp = cache && cache.getItem(href + ':timestamp');
var styles = { css: css, timestamp: timestamp };
xhr(sheet.href, function (data, lastModified) {
if (!reload && styles &&
(new(Date)(lastModified).valueOf() ===
new(Date)(styles.timestamp).valueOf())) {
// Use local copy
createCSS(styles.css, sheet);
callback(null, sheet, { local: true, remaining: remaining });
} else {
// Use remote copy (re-parse)
new(less.Parser)({
optimization: less.optimization,
paths: [href.replace(/[\w\.-]+$/, '')]
}).parse(data, function (e, root) {
if (e) { return error(e, href) }
try {
callback(root, sheet, { local: false, lastModified: lastModified, remaining: remaining });
removeNode(document.getElementById('less-error-message:' + extractId(href)));
} catch (e) {
error(e, href);
}
});
}
}, function (status, url) {
throw new(Error)("Couldn't load " + url+ " (" + status + ")");
});
}
function extractId(href) {
return href.replace(/^[a-z]+:\/\/?[^\/]+/, '' ) // Remove protocol & domain
.replace(/^\//, '' ) // Remove root /
.replace(/\?.*$/, '' ) // Remove query
.replace(/\.[^\.\/]+$/, '' ) // Remove file extension
.replace(/[^\.\w-]+/g, '-') // Replace illegal characters
.replace(/\./g, ':'); // Replace dots with colons(for valid id)
}
function createCSS(styles, sheet, lastModified) {
var css;
// Strip the query-string
var href = sheet.href ? sheet.href.replace(/\?.*$/, '') : '';
// If there is no title set, use the filename, minus the extension
var id = 'less:' + (sheet.title || extractId(href));
// If the stylesheet doesn't exist, create a new node
if ((css = document.getElementById(id)) === null) {
css = document.createElement('style');
css.type = 'text/css';
css.media = sheet.media;
css.id = id;
document.getElementsByTagName('head')[0].appendChild(css);
}
if (css.styleSheet) { // IE
try {
css.styleSheet.cssText = styles;
} catch (e) {
throw new(Error)("Couldn't reassign styleSheet.cssText.");
}
} else {
(function (node) {
if (css.childNodes.length > 0) {
if (css.firstChild.nodeValue !== node.nodeValue) {
css.replaceChild(node, css.firstChild);
}
} else {
css.appendChild(node);
}
})(document.createTextNode(styles));
}
// Don't update the local store if the file wasn't modified
if (lastModified && cache) {
log('saving ' + href + ' to cache.');
cache.setItem(href, styles);
cache.setItem(href + ':timestamp', lastModified);
}
}
function xhr(url, callback, errback) {
var xhr = getXMLHttpRequest();
var async = isFileProtocol ? false : less.async;
if (typeof(xhr.overrideMimeType) === 'function') {
xhr.overrideMimeType('text/css');
}
xhr.open('GET', url, async);
xhr.send(null);
if (isFileProtocol) {
if (xhr.status === 0) {
callback(xhr.responseText);
} else {
errback(xhr.status);
}
} else if (async) {
xhr.onreadystatechange = function () {
if (xhr.readyState == 4) {
handleResponse(xhr, callback, errback);
}
};
} else {
handleResponse(xhr, callback, errback);
}
function handleResponse(xhr, callback, errback) {
if (xhr.status >= 200 && xhr.status < 300) {
callback(xhr.responseText,
xhr.getResponseHeader("Last-Modified"));
} else if (typeof(errback) === 'function') {
errback(xhr.status, url);
}
}
}
function getXMLHttpRequest() {
if (window.XMLHttpRequest) {
return new(XMLHttpRequest);
} else {
try {
return new(ActiveXObject)("MSXML2.XMLHTTP.3.0");
} catch (e) {
log("browser doesn't support AJAX.");
return null;
}
}
}
function removeNode(node) {
return node && node.parentNode.removeChild(node);
}
function log(str) {
if (less.env == 'development' && typeof(console) !== "undefined") { console.log('less: ' + str) }
}
function error(e, href) {
var id = 'less-error-message:' + extractId(href);
if (! e.extract) { throw e }
var template = ['<div>',
'<pre class="ctx"><span>[-1]</span>{0}</pre>',
'<pre><span>[0]</span>{current}</pre>',
'<pre class="ctx"><span>[1]</span>{2}</pre>',
'</div>'].join('\n');
var elem = document.createElement('div'), timer;
elem.id = id;
elem.className = "less-error-message";
elem.innerHTML = '<h3>' + (e.message || 'There is an error in your .less file') + '</h3>' +
'<p><a href="' + href + '">' + href + "</a> " +
'on line ' + e.line + ', column ' + (e.column + 1) + ':</p>' +
template.replace(/\[(-?\d)\]/g, function (_, i) {
return (parseInt(e.line) + parseInt(i)) || '';
}).replace(/\{(\d)\}/g, function (_, i) {
return e.extract[parseInt(i)] || '';
}).replace(/\{current\}/, e.extract[1].slice(0, e.column) +
'<span class="error">' +
e.extract[1].slice(e.column) +
'</span>');
// CSS for error messages
createCSS([
'.less-error-message span {',
'margin-right: 15px;',
'}',
'.less-error-message pre {',
'color: #ee4444;',
'padding: 4px 0;',
'margin: 0;',
'}',
'.less-error-message pre.ctx {',
'color: #dd7777;',
'}',
'.less-error-message h3 {',
'padding: 15px 0 5px 0;',
'margin: 0;',
'}',
'.less-error-message a {',
'color: #10a',
'}',
'.less-error-message .error {',
'color: red;',
'font-weight: bold;',
'padding-bottom: 2px;',
'border-bottom: 1px dashed red;',
'}'
].join('\n'), { title: 'error-message' });
elem.style.cssText = [
"font-family: Arial, sans-serif",
"border: 1px solid #e00",
"background-color: #eee",
"border-radius: 5px",
"-webkit-border-radius: 5px",
"-moz-border-radius: 5px",
"color: #e00",
"padding: 15px",
"margin-bottom: 15px"
].join(';');
/*if (less.env == 'development') {
timer = setInterval(function () {
if (document.body) {
if (document.getElementById(id)) {
document.body.replaceChild(elem, document.getElementById(id));
} else {
document.body.insertBefore(elem, document.body.firstChild);
}
clearInterval(timer);
}
}, 10);
}*/
}
})(window);
|
var fs = require('fs'),
gulp = require('gulp'),
es = require('event-stream'),
concat = require('gulp-concat'),
config = require('../config');
/**
* Build vendor, Concat and build our dependencies
*/
gulp.task('vendor', function() {
"use strict";
return es.concat(
gulp.src(config.vendorJS)
.pipe(concat("vendor.min.js"))
.pipe(gulp.dest(config.dest + '/js/'))
);
});
|
import React, { PropTypes } from 'react';
import colorByCharacter from '~/constants/colorByCharacter';
function WordCard(props) {
const { word, isClues } = props;
let cardClasses = `flex flex--jc--c align-items--center card--container `;
if (isClues) {
cardClasses += ' flip ';
cardClasses += word.isRevealed ? ' opacity--4-10 ' : ' cursor--pointer ';
} else {
cardClasses += word.isRevealed && ' flip ';
}
function toggleIsRevealed(word) {
props.toggleIsRevealed && props.toggleIsRevealed(word);
}
return (
<div
className={`grid__item col-1-5 height--80 mv-`}
>
<div
onClick={() => word.isRevealed ? null : toggleIsRevealed(word)}
className={cardClasses}
>
<div className="grid grid--full col-1-1 card">
<div className="grid__item col-1-1 flex align-items--center flex--jc--c text--center font--lg front">
{word.text.toLowerCase()}
</div>
<div className={`grid__item col-1-1 flex align-items--center flex--jc--c text--center font--lg back ${colorByCharacter[word.character]}`}>
{word.text.toLowerCase()}
</div>
</div>
</div>
</div>
);
}
WordCard.propTypes = {
word: PropTypes.object.isRequired,
toggleIsRevealed: PropTypes.func.isRequired,
isClues: PropTypes.bool,
};
export default WordCard;
|
import { expect } from 'chai';
import $ from './data/_.fixes'; // FORMS
import Form from '../src';
describe('$A Field values checks', () => {
it('$A qwerty value should be equal to "0"', () =>
expect($.$A.$('qwerty').value).to.be.equal(0));
});
describe('$B Field values checks', () => {
it('$B inventoryLevel.value value should be equal to "2"', () =>
expect($.$B.$('inventoryLevel.value').value).to.be.equal(2));
it('$B addOns[0].nested.value value should be equal to "3"', () =>
expect($.$B.$('addOns[0].nested.value').value).to.be.equal(3));
});
describe('$C Field values checks', () => {
it('$C itineraryItems[0].hotel.name value value should be equal to "The Plaza"', () =>
expect($.$C.$('itineraryItems[0].hotel.name').value).to.be.equal('The Plaza'));
it('$C itineraryItems[1].hotel.name value value should be equal to "Beverly Hills Hotel"', () =>
expect($.$C.$('itineraryItems[1].hotel.name').value).to.be.equal('Beverly Hills Hotel'));
it('$C itineraryItems[2].hotel.name value value should be equal to "Trump Hotel"', () =>
expect($.$C.$('itineraryItems[2].hotel.name').value).to.be.equal('Trump Hotel'));
});
describe('$D Field values checks', () => {
it('$D itineraryItem value value should be equal to "itinerary-item-value"', () =>
expect($.$D.$('itineraryItem').value).to.be.equal('itinerary-item-value'));
it('$D itineraryItems[0].hotel.name value value should be equal to "New Test Name"', () =>
expect($.$D.$('itineraryItems[0].hotel.name').value).to.be.equal('New Test Name'));
it('$D itineraryItems[1].hotel.name value value should be equal to "New Test Name"', () =>
expect($.$D.$('itineraryItems[1].hotel.name').value).to.be.equal('New Test Name'));
it('$D itineraryItems[2].hotel.name value value should be equal to "New Test Name"', () =>
expect($.$D.$('itineraryItems[2].hotel.name').value).to.be.equal('New Test Name'));
});
describe('$C Form values() method checks', () => {
const prop = {
0: 'itineraryItems[0].hotel.name',
1: 'itineraryItems[1].hotel.name',
2: 'itineraryItems[2].hotel.name',
};
it(`$C values() ${prop[0]} should be equal to "The Plaza"`, () =>
expect($.$C.values()).to.have.deep.property(prop[0], 'The Plaza'));
it(`$C values() ${prop[1]} should be equal to "Beverly Hills Hotel"`, () =>
expect($.$C.values()).to.have.deep.property(prop[1], 'Beverly Hills Hotel'));
it(`$C values() ${prop[2]} should be equal to "Trump Hotel"`, () =>
expect($.$C.values()).to.have.deep.property(prop[2], 'Trump Hotel'));
});
describe('$D Form values() method checks', () => {
const prop = {
0: '[0].hotel.name',
1: '[1].hotel.name',
2: '[2].hotel.name',
};
it(`$D values() ${prop[0]} should be equal to "New Test Name"`, () =>
expect($.$D.$('itineraryItems').values()).to.have.deep.property(prop[0], 'New Test Name'));
it(`$D values() ${prop[1]} should be equal to "New Test Name"`, () =>
expect($.$D.$('itineraryItems').values()).to.have.deep.property(prop[1], 'New Test Name'));
it(`$D values() ${prop[2]} should be equal to "New Test Name"`, () =>
expect($.$D.$('itineraryItems').values()).to.have.deep.property(prop[2], 'New Test Name'));
});
describe('Check Nested $E values()', () => {
it('$E places values() should be array', () =>
expect($.$E.$('places').values()).to.be.instanceof(Array));
it('$E places values() should be length of 0', () =>
expect($.$E.values().places).to.have.lengthOf(0));
it('$E places values() should be length of 0', () =>
expect($.$E.$('places').values()).to.have.lengthOf(0));
});
describe('Check Nested $F value computed', () => {
it('$F inventoryLevel.value value should be equal to "2"', () =>
expect($.$F.$('inventoryLevel.value').value).to.be.equal(2));
it('$F places value should be array', () =>
expect($.$F.$('places').value).to.be.instanceof(Array));
it('$F places value should be length of 2', () =>
expect($.$F.$('places').value).to.have.lengthOf(2));
it('$F skills value should be array', () =>
expect($.$F.$('skills').value).to.be.instanceof(Array));
it('$F skills value should be length of 0', () =>
expect($.$F.$('skills').value).to.have.lengthOf(0));
it('$F date value should be equal to "1976-07-02T22:00:00.000Z"', () =>
expect($.$F.$('date').value.getTime()).to.be.equal(new Date(1976, 6, 3).getTime()));
it('$F members[0].hobbies value should be array', () =>
expect($.$F.$('members[0].hobbies').value).to.be.instanceof(Array));
it('$F members[0].hobbies value should be length of 3', () =>
expect($.$F.$('members[0].hobbies').value).to.have.lengthOf(3));
it('$F members[1].hobbies value should be array', () =>
expect($.$F.$('members[1].hobbies').value).to.be.instanceof(Array));
it('$F ids value should be length of 3', () =>
expect($.$F.$('ids').value).to.have.lengthOf(3));
it('$F ids value should be array', () =>
expect($.$F.$('ids').value).to.be.instanceof(Array));
});
describe('Check Nested $H value computed', () => {
it('$H items[0].name value should be equal to "Item #A"', () =>
expect($.$H.$('items[0].name').value).to.be.equal('Item #A'));
it('$H items[2].name value should be equal to "Item #3"', () =>
expect($.$H.$('items[2].name').value).to.be.equal('Item #3'));
it('$H singleFieldArray value should be array', () =>
expect($.$H.$('singleFieldArray').value).to.be.instanceof(Array));
it('$H singleFieldEmptyArray value should be array', () =>
expect($.$H.$('singleFieldEmptyArray').value).to.be.instanceof(Array));
it('$H singleFieldEmptyObject value should be object', () =>
expect($.$H.$('singleFieldEmptyObject').value).to.be.instanceof(Object));
it('$H singleFieldArray value should be array', () =>
expect($.$H.$('singleFieldArray').value).to.have.lengthOf(1));
it('$H singleFieldEmptyArray value should be array', () =>
expect($.$H.$('singleFieldEmptyArray').value).to.have.lengthOf(0));
});
describe('Check Fixes $I values', () => {
it('$I layout.column1[0].title value should be a equal to "THE NEW TITLE"', () =>
expect($.$I.$('layout.column1[0].title').value).to.be.equal('THE NEW TITLE'));
it('$I deep.nested.column2[0].title value should be a equal to "THE NEW TITLE"', () =>
expect($.$I.$('deep.nested.column2[0].title').value).to.be.equal('THE NEW TITLE'));
it('$I deep.nested.column3[0].title value should be a equal to "THE NEW TITLE"', () =>
expect($.$I.$('deep.nested.column3[0].title').value).to.be.equal('THE NEW TITLE'));
});
describe('Check Fixes $M values', () => {
it('$M people[0].name value should be null', () =>
expect($.$M.$('people[0].name').value).to.be.null);
it('$M items[0].name value should be equal to zero', () =>
expect($.$M.$('items[0].name').value).to.be.equal(0));
it('$M number value should be equal to zero', () =>
expect($.$M.$('number').value).to.be.equal(0));
it('$M array value should be length of 3', () =>
expect($.$M.$('array').value).to.have.lengthOf(3));
it('$M array value should be array', () =>
expect($.$M.$('array').value).to.be.instanceof(Array));
it('$M array[0].name value should be a equal to ""', () =>
expect($.$M.$('array[0].name').value).to.be.equal(''));
it('$M array[1].name value should be a equal to ""', () =>
expect($.$M.$('array[0].name').value).to.be.equal(''));
it('$M array[2].name value should be a equal to ""', () =>
expect($.$M.$('array[2].name').value).to.be.equal(''));
});
describe('Check Fixes $O values', () => {
it('$O roles value should be an array', () =>
expect($.$O.$('roles').value).to.be.instanceof(Array));
it('$O roles value should be empty', () =>
expect($.$O.$('roles').value).to.be.empty);
it('$O roles value should be an array', () =>
expect($.$O.$('array').value).to.be.instanceof(Array));
it('$O roles value should be empty', () =>
expect($.$O.$('array').value).to.be.empty);
});
describe('Check Fixes $P values', () => {
const values = { street: '123 Fake St.', zip: '12345' };
const labels = { street: 'street-label', zip: 'zip-label' };
it('$P address values() check', () =>
expect($.$P.$('address').values()).to.be.deep.equal(values));
it('$P address value check', () =>
expect($.$P.$('address').value).to.be.deep.equal(values));
it('$P address value check', () =>
expect($.$P.$('address').labels()).to.be.deep.equal(labels));
});
describe('Check Fixes $Q values', () => {
const a = [{ id: 1, name: 'name' }];
const b = [{ id: 1, name: 'name', value: 'some val' }];
it('$Q arrayFieldA values() check', () =>
expect($.$Q.$('arrayFieldA').values()).to.be.deep.equal(a));
it('$Q arrayFieldB values() check', () =>
expect($.$Q.$('arrayFieldB').values()).to.be.deep.equal(b));
it('$Q arrayFieldA value check', () =>
expect($.$Q.$('arrayFieldA').value).to.be.deep.equal(a));
it('$Q arrayFieldB value check', () =>
expect($.$Q.$('arrayFieldB').value).to.be.deep.equal(b));
});
describe('Check Fixes $Q1 values', () => {
it('$Q1 values check', () =>
expect($.$Q1.values())
.to.be.deep.equal({
other: {
nested: 'nested-value',
},
tags: [{
id: 'x',
name: 'y',
}],
}));
});
describe('Check Fixes $R values', () => {
const a = $.$R.values().organization;
const b = $.$R.$('organization').value;
it('$R values().organization check', () =>
expect(a).to.be.deep.equal(b));
it('$R organization value check', () =>
expect(b).to.be.deep.equal(b));
});
describe('Check Fixes $S deleting by path', () => {
const a = $.$S.$('array');
const hasItemToDelete3 = $.$S.has('item_to_delete3');
it('$S array field check', () =>
expect(a.size).to.eq(0));
it('$S deleted from root', () =>
expect(hasItemToDelete3).to.be.false);
});
describe('Check Fixes $425 values', () => {
it('$425 values() check', () =>
expect($.$425.values())
.to.be.deep.equal({
'1a': ' ',
'2a': ' ',
'3a': ' ',
}));
});
describe('$481 Field values checks', () => {
it('$481 length value should be equal to "0"', () =>
expect($.$481.$('length').value).to.be.equal(0));
});
describe('separated has correct definition', () => {
it('', () => {
expect($.$492.$('club.name').value).to.be.equal('')
expect($.$492.$('club.city').value).to.be.equal('')
expect($.$492.values())
.to.be.deep.equal({
club: {
name: '',
city: ''
}
})
})
});
describe('set null value', () => {
it('', () => {
expect($.$495.$('club.name').value).to.be.equal('JJSC')
expect($.$495.$('club.city').value).to.be.equal('Taipei')
$.$495.$('club').set(null)
expect($.$495.values())
.to.be.deep.equal({
club: {
name: '',
city: ''
}
})
})
});
describe('falsy fallback', () => {
it('', () => {
expect($.$505.$('club.name').value).to.be.equal('JJSC')
expect($.$505.$('club.city').value).to.be.equal('Taipei')
expect($.$505.$('club').has('area')).to.be.equal(false)
expect(()=>$.$495.$('club.area')).to.throw('field is not defined')
})
});
describe('null date', () => {
it('', () => {
expect($.$507.$('people.0.birthday').value).to.be.equal(null)
expect($.$507.$('people').add().$('birthday').value).to.be.equal(null)
})
});
describe('update with input', () => {
it('', () => {
expect($.$514.$('priority').value).to.be.equal(1)
expect($.$514.$('itineraryItems.0.hotel.starRating').value).to.be.equal(5)
})
});
describe('new form with nested array values', () => {
it('', () => {
const fields = [
'purpose',
'trip.itineraryItems[].hotel.name',
'trip.itineraryItems[].hotel.starRating',
];
const values = {
purpose: 'Summer vacation',
trip: {
itineraryItems: [{
hotel: {
name: 'Shangri-La Hotel',
starRating: '5.0',
},
}, {
hotel: null,
}, {
hotel: {
name: 'Trump Hotel',
starRating: '5.0',
},
}]
}
}
const $516 = new Form({fields, values}, {name: 'Form 516'})
expect($516.$('purpose').value).to.be.equal('Summer vacation')
expect($516.$('trip.itineraryItems').size).to.be.equal(3)
})
});
describe('update to nested array items', () => {
it('', () => {
const fields = [
'bulletin',
'bulletin.jobs',
'bulletin.jobs[].jobId',
'bulletin.jobs[].companyName',
];
const values = {
bulletin: {
jobs: [
{
jobId: 1,
companyName: 'Acer'
},
{
jobId: 2,
companyName: 'Asus'
}]
}
};
const $521 = new Form({fields, values}, {name: 'Form 521'})
// debugger
$521.update({
bulletin: {
jobs: [{
jobId: 1,
companyName: 'Apple'
}]
}
})
expect($521.$('bulletin.jobs').size).to.be.equal(1)
expect($521.$('bulletin.jobs.0.jobId').value).to.be.equal(1)
expect($521.$('bulletin.jobs.0.jobId').isDirty).to.be.equal(false)
expect($521.$('bulletin.jobs.0.companyName').value).to.be.equal('Apple')
expect($521.$('bulletin.jobs.0.companyName').isDirty).to.be.equal(true)
expect($521.$('bulletin.jobs.0').isDirty).to.be.equal(true)
expect($521.$('bulletin.jobs').isDirty).to.be.equal(true)
})
});
describe('#523', () => {
it('', () => {
const fields = [{
name: 'fieldA',
label: 'fieldA'
}, {
name: 'fieldB',
label: 'fieldB',
fields: [{
name: "nestedB",
label: "nestedB"
}]
}];
const $523 = new Form({fields}, {name: 'Form 523'})
expect($523.isDirty).to.be.false
})
});
describe('update nested nested array items', () => {
it('', () => {
const fields = [
'pricing',
'pricing.value[]',
'pricing.value[].prices[]',
'pricing.value[].prices[].money',
'pricing.value[].prices[].quantity',
];
const values = {
pricing: {
value: [
{
prices: [{
money: 35,
quantity: 1
}]
}
]
}
};
const $526 = new Form({fields, values}, {name: 'Form 526'})
console.debug('pricing.value.0.initial', $526.$('pricing.value.0').initial)
console.debug('pricing.value.0.prices.initial', $526.$('pricing.value.0.prices').initial)
$526.update({
pricing: {
value: [
{
prices: [
{
money: 35,
quantity: 1
},
{
money: 100,
quantity: 3
}
]
}
]
}
})
console.debug('pricing.value.0.initial', $526.$('pricing.value.0').initial)
console.debug('pricing.value.0.prices.initial', $526.$('pricing.value.0.prices').initial)
expect($526.$('pricing.value').isDirty).to.be.equal(true)
expect($526.$('pricing.value.0').isDirty).to.be.equal(true)
expect($526.$('pricing.value.0.prices').isDirty).to.be.equal(true)
})
});
describe('falsy fallback for array items', () => {
it('', () => {
const fields = [
'purpose',
'trip.itineraryItems[].hotel.name',
'trip.itineraryItems[].hotel.starRating',
];
const values = {
purpose: 'Summer vacation',
trip: {
itineraryItems: [{
hotel: {
name: 'Shangri-La Hotel',
starRating: '5.0',
favorite: true
},
}, {
hotel: null,
}, {
hotel: {
name: 'Trump Hotel',
starRating: '5.0',
favorite: false
},
}]
}
}
const $527 = new Form({fields, values}, {name: 'Form 527', options:{fallback: false}})
expect($527.$('purpose').value).to.be.equal('Summer vacation')
expect($527.$('trip.itineraryItems').size).to.be.equal(3)
expect($527.$('trip.itineraryItems.0.hotel')).not.to.be.undefined
expect($527.select('trip.itineraryItems.0.hotel.favorite', null, false)).to.be.undefined
})
});
|
// External Dependencies
import React, { Component } from 'react';
import PropTypes from 'prop-types';
import _ from 'lodash';
// Our Dependencies
import { track } from '../../util/analytics';
import * as BooksAPI from '../../BooksAPI';
import { getSuggetions } from '../../util/search';
// Our Components
import BookList from '../BookList';
export default class Search extends Component {
static propTypes = {
onBackClick: PropTypes.func.isRequired,
isFetching: PropTypes.bool.isRequired,
onShelfChange: PropTypes.func.isRequired,
books: PropTypes.array.isRequired,
onBookClick: PropTypes.func.isRequired,
}
state = {
query: '',
isSearching: false,
results: [],
}
// istanbul ignore next
componentDidMount() {
const { lastQuery } = localStorage;
if (lastQuery) {
this.updateQuery(lastQuery);
}
track(window);
}
componentWillReceiveProps =({ books }) => {
const clonedResults = _.cloneDeep(this.state.results);
books.forEach(b => {
clonedResults.forEach((r, i, arr) => {
if (r.id === b.id) {
arr[i].shelf = b.shelf;
}
})
});
this.setState({ results: clonedResults });
}
updateQuery = (query) => {
this.setState({ query });
// Store query so it can be retrieved
// when the back arrow is clicked
// from the BookDetail screen
localStorage.lastQuery = query;
// If query is empty do
// not send an API request
if (query.trim().length > 0) {
this.setState({ isSearching: true });
BooksAPI.search(query).then(resp => {
let results = [];
// Only set state if resp is an array
// since the endpoint returns undefined
// and an error object as well
if (Array.isArray(resp)) {
const { books } = this.props;
// istanbul ignore next
books.forEach(b => {
resp.forEach((r, i, arr) => {
if (r.id === b.id) {
arr[i].shelf = b.shelf;
}
})
});
results = resp;
}
this.setState({ results, isSearching: false });
})
} else {
this.setState({ results: [] });
}
}
render() {
const { query, results, isSearching } = this.state;
const { onBackClick, onShelfChange, isFetching, onBookClick } = this.props;
const suggestions = getSuggetions();
return (
<div>
<div className="search-books">
<div className="search-books-bar">
<a className="close-search" onClick={() => onBackClick()}>Close</a>
<div className={isSearching ? "animated loading-bar" : ""}></div>
<div className="search-books-input-wrapper">
<input
type="text"
placeholder="Search by Title or Author"
value={query}
onChange={(e) => this.updateQuery(e.target.value)}
/>
</div>
</div>
<div className="search-books-results">
{/*
If results were returned and something
was searched for show the following
*/}
{ !!results.length &&
!!query.length && (
<ol className="books-grid">
<BookList
onShelfChange={onShelfChange}
books={results}
isFetching={isFetching}
onBookClick={onBookClick}
/>
</ol>
)}
{/*
If no results were returned,
we are not currently searching
and text has been typed in the
search box then display the following
*/}
{ !results.length &&
!isSearching &&
!!query.length && (
<div className="search-not-found">
<h2>Could not find anything 😣</h2>
<div>Try search for
<strong> {suggestions[0]} </strong> or
<strong> {suggestions[1]} </strong>
</div>
</div>
)}
</div>
</div>
</div>
)
}
} |
module.exports = {
rules: {
'no-undef': 0,
},
};
|
'use strict';
var app = angular.module('app', ['ngRoute', 'ngResource', 'ngMaterial', 'ngAnimate', 'textAngular', 'ngSanitize', 'ngMessages', 'ngPassword', 'ngCookies', 'appFilters'])
.config(['$routeProvider', '$locationProvider', '$mdThemingProvider',
function ($routeProvider, $locationProvider, $mdThemingProvider) {
$routeProvider
.when('/', {
templateUrl: 'static/partials/landing.html',
controller: 'PostListController'
})
.when('/about', {
templateUrl: 'static/partials/about.html',
controller: 'AboutController'
})
.when('/posts', {
templateUrl: 'static/partials/post-list.html',
controller: 'PostListController'
})
.when('/new', {
templateUrl: 'static/partials/new_post.html',
controller: 'NewPostController'
})
.when('/edit', {
templateUrl: 'static/partials/new_post.html',
controller: 'EditPostController'
})
.when('/posts/:slug', {
templateUrl: '/static/partials/post-detail.html',
controller: 'PostDetailController',
resolve: {
response: function ($route, postService) {
return postService.getPosts($route.current.params.slug);
}
}
})
.when('/register', {
templateUrl: 'static/partials/register.html',
controller: 'UserController'
})
.when('/login', {
templateUrl: 'static/partials/register.html',
controller: 'UserController'
})
.when('/me/posts', {
templateUrl: 'static/partials/my_posts.html',
controller: 'UserPostsController'
})
.when('/users/:user', {
templateUrl: 'static/partials/user_details.html',
controller: 'UserProfileController'
})
.when('/me/profile', {
templateUrl: 'static/partials/profile.html',
controller: 'UserDetailsController'
})
.otherwise({
redirectTo: '/'
});
//Customize themes for Angular Material
$mdThemingProvider.theme('default')
.primaryPalette('blue-grey')
.accentPalette('red')
.warnPalette('deep-orange')
.backgroundPalette('grey');
$locationProvider.html5Mode(true);
}
])
.run(function ($rootScope, $location, $cookies, userService) {
$rootScope.$on("$routeChangeStart", function (event, next) {
if (next.templateUrl == 'static/partials/new_post.html' || next.templateUrl == 'static/partials/profile.html'
|| next.templateUrl == 'static/partials/my_posts.html') {
var user = $cookies.get('current_user');
if (!user) {
$location.path("/login");
}
}
});
userService.isLoggedIn();
});
angular.module('app')
.directive('fileModel', ['$parse', function ($parse) {
return {
restrict: 'A',
link: function (scope, element, attrs) {
var model = $parse(attrs.fileModel);
var modelSetter = model.assign;
element.bind('change', function () {
scope.$apply(function () {
modelSetter(scope, element[0].files[0]);
});
});
}
};
}])
.directive('post', function () {
return {
restrict: 'E',
controller: 'PostController',
templateUrl: 'static/partials/post.html',
replace: true
};
})
.directive('postMenu', function () {
return {
restrict: 'E',
controller: 'PostController',
templateUrl: 'static/partials/post-elements/post-menu.html',
replace: true
};
});
'use strict';
/* Filters */
angular.module('appFilters', [])
.filter('localDate', function () {
return function (input) {
return moment(new Date(input)).format('MMM D YYYY HH:mm');
}
});
'use strict';
angular.module('app')
// A service to share 'post' object between controllers
.service('sharedPost', function () {
var post = this;
})
// Service with methods related to operation on/with posts
.service('postService', ['$http', '$mdDialog', '$cookies', function ($http, $mdDialog, $cookies) {
/* Check if the logged in user has favorited the post and add red color to fav icon if yes.
* Allows to pass in user as u for testing.
*/
this.checkFav = function (post, u) {
var user = u || $cookies.getObject('current_user');
if (user && post.favorited_by) {
var filtered = post.favorited_by.filter(function (el) {
return el.username == user.username;
});
return filtered.length > 0;
}
};
// Ask user for confirmation and delete a post
this.delete = function (ev, postId) {
var confirm = $mdDialog.confirm()
.title('Are you sure you want to delete this post?')
.textContent('This action cannot be undone.')
.ariaLabel('Confirm post deletion')
.targetEvent(ev)
.ok('Delete')
.cancel('Cancel');
return $mdDialog.show(confirm).then(function () {
return $http.post("/blog/api/posts/" + postId + "/delete", {})
});
};
this.confirmUnpublish = function (ev, post) {
var confirm = $mdDialog.confirm()
.title('Are you sure you want to unpublish this post?')
.textContent('This will make it not visible to public.')
.ariaLabel('Confirm post unpublishing')
.targetEvent(ev)
.ok('Unpublish')
.cancel('Cancel');
return $mdDialog.show(confirm);
};
this.editPost = function (file, data) {
var fd = new FormData();
fd.append('file', file);
fd.append('post', JSON.stringify(data));
return $http.post("/blog/api/posts/" + data.id + "/edit", fd, {
transformRequest: angular.identity,
headers: {'Content-Type': undefined}
})
};
this.favorite = function (post) {
return $http.post("/blog/api/posts/" + post.slug, {});
};
this.getPosts = function (slug) {
if (slug) {
return $http.get('/blog/api/posts/' + slug, {});
} else {
return $http.get('/blog/api/posts', {});
}
};
this.newPost = function (file, data) {
var fd = new FormData();
fd.append('file', file);
fd.append('post', JSON.stringify(data));
return $http.post("/blog/api/posts/new", fd, {
transformRequest: angular.identity,
headers: {'Content-Type': undefined}
})
};
this.unpublish = function (ev, post) {
return this.confirmUnpublish(ev, post).then(function () {
return $http.post('/blog/api/posts/' + post.id + '/unpublish', {})
});
};
}])
.service('imgPreview', function () {
this.preview = function (element, scope) {
var reader = new FileReader();
reader.onload = function (event) {
scope.imageSrc = event.target.result;
scope.$apply();
};
// when the file is read it triggers the onload event above.
reader.readAsDataURL(element.files[0]);
};
this.activateUpload = function (id) {
document.getElementById(id).click();
}
})
.service('favoritePost', ['$http', '$cookies', function ($http, $cookies) {
this.favorite = function (post) {
return $http.post("/blog/api/posts/" + post.slug, {});
};
/* Check if the logged in user has favorited the post and add red color to fav icon if yes */
this.checkFav = function (post) {
var user = $cookies.getObject('current_user');
if (user) {
var filtered = post.favorited_by.filter(function (el) {
return el.username == user.username;
});
if (filtered.length) {
post.favClass = 'red';
} else {
post.favClass = '';
}
}
}
}])
.service('addComment', ['$http', function ($http) {
this.add = function (comment, postId) {
return $http.post("/blog/api/posts/" + postId + "/comments/new", JSON.stringify(comment))
}
}])
.service('goTo', ['$anchorScroll', '$location', function ($anchorScroll, $location) {
this.goTo = function (post, el) {
var selector = document.getElementById(el);
// If we are on post detail page, scroll to comments
if (selector) {
$location.hash(el);
$anchorScroll();
// Else go to post detail page and jump to comments
} else {
$location.path('/posts/' + post.slug).hash(el);
}
}
}])
.service('toast', ['$mdToast', function ($mdToast) {
this.showToast = function (message, delay) {
return $mdToast.show(
$mdToast.simple()
.textContent(message)
.position('right top')
.hideDelay(delay)
);
}
}])
.service('userService', ['$http', '$cookies', function ($http, $cookies) {
/*
* Check if the user is still logged in on the server in case there were some errors or database reset
* to prevent the situations when user is logged out on the server but logged in in the browser
*/
this.isLoggedIn = function () {
return $http.get("/blog/api/current_user")
.then(function (response) {
var msg = response.data.message;
if (msg === 'no user' && $cookies.get('current_user')) {
$cookies.remove('current_user');
}
// Fallback in case there is an unexpected server error
}, function () {
if ($cookies.get('current_user')) {
$cookies.remove('current_user');
}
});
};
this.newUser = function (file, user) {
var fd = new FormData();
fd.append('file', file);
fd.append('user', JSON.stringify(user));
return $http.post("/blog/api/users", fd, {
transformRequest: angular.identity,
headers: {'Content-Type': undefined}
});
};
this.update = function (file, user) {
var fd = new FormData();
fd.append('file', file);
fd.append('user', JSON.stringify(user));
return $http.post("/blog/api/users/edit", fd, {
transformRequest: angular.identity,
headers: {'Content-Type': undefined}
});
};
this.login = function (user) {
return $http.post("/login", user);
};
this.logout = function () {
return $http.post("/logout", {});
};
this.getPosts = function (username) {
return $http.get("/blog/api/users/" + username + "/posts")
};
this.getDetails = function (username) {
return $http.get("/blog/api/users/" + username);
}
}])
;
'use strict';
app.controller('AboutController', ['$scope', function ($scope) {
$scope.page.loading = false;
}]);
'use strict';
app.controller('EditPostController', ['$scope', 'postService', '$location', 'imgPreview', 'sharedPost', 'toast', '$window',
function ($scope, postService, $location, imgPreview, sharedPost, toast, $window) {
$scope.page.loading = false; // loading progress bar
$scope.heading = 'Edit';
$scope.button = 'Save changes';
$scope.post = sharedPost.post;
$scope.post.disabled = true;
$scope.createPost = function (form, post, publish) {
if (form.$valid) {
$scope.loading = true; // loading spinner
var file = $scope.myFile;
post.public = publish || post.public;
postService.editPost(file, post)
.then(function success(response) {
$scope.loading = false;
if (post.public) {
toast.showToast('Post edited', 1000).then(function () {
$window.location.reload();
$location.path('/posts/' + response.data.slug);
});
} else {
toast.showToast('Changes saved', 1000)
}
}, function error(response) {
$scope.loading = false;
toast.showToast('Could not edit post. Please try again later', 5000);
});
}
};
$scope.setFile = function (element) {
return imgPreview.preview(element, $scope);
};
$scope.activateUpload = function () {
return imgPreview.activateUpload('uploadImage');
}
}]);
'use strict';
app.controller('MainController', ['$scope', '$rootScope', 'userService', '$cookies', '$location', 'imgPreview', 'toast',
'sharedPost', function ($scope, $rootScope, userService, $cookies, $location, imgPreview, toast, sharedPost) {
$scope.page = {};
$scope.page.loading = false;
$scope.isOpen = false;
$scope.currentUser = function () {
return $cookies.get('current_user');
};
/* Separate function to get user details to avoid loops with JSON.parse since
currentUser() is called constantly */
$scope.getUserDetails = function () {
if ($scope.currentUser()) {
return JSON.parse($scope.currentUser());
}
};
$scope.user = $scope.getUserDetails();
$scope.logout = function () {
if ($scope.currentUser()) {
userService.logout()
.then(function success() {
$cookies.remove('current_user');
$location.path('/');
}, function error(response) {
console.log('Could not log out', response);
});
}
};
$scope.setFile = function (element) {
return imgPreview.preview(element, $scope);
};
$scope.activateUpload = function () {
return imgPreview.activateUpload('uploadAva');
};
/* Redirect to '/new' route and clear the sharedPost since we are not editing but creating a new post */
$scope.createPost = function () {
sharedPost.post = {};
$location.path('/new');
};
}]);
'use strict';
app.controller('NewPostController', ['$scope', 'postService', '$location', 'imgPreview', '$cookies', 'toast',
function ($scope, postService, $location, imgPreview, $cookies, toast) {
$scope.page.loading = false; // loading progress bar
var currentUser = $cookies.getObject('current_user');
$scope.heading = 'Create';
$scope.button = 'Save';
if (currentUser) {
$scope.post = {
title: '',
author: currentUser.username,
avatar: currentUser.avatar,
date: new Date(),
cover_photo: '../img/covers/default.jpg',
disabled: true
};
}
$scope.createPost = function (form, post, publish) {
if (form.$valid) {
$scope.loading = true; // loading spinner
var file = $scope.myFile;
post.public = publish;
postService.newPost(file, post)
.then(function success(response) {
$scope.loading = false;
toast.showToast('Post saved', 1000).then(function () {
$location.path('/posts/' + response.data.slug);
})
}, function error(response) {
$scope.loading = false;
toast.showToast('Could not save post. Please try again later', 5000);
});
}
};
$scope.publish = function (form, post) {
if (form.$valid) {
$scope.loading = true; // loading spinner
var file = $scope.myFile;
postService.newPost(file, $scope.post)
.then(function success(response) {
$scope.loading = false;
toast.showToast('Post saved', 1000).then(function () {
$location.path('/posts/' + response.data.slug);
})
}, function error(response) {
$scope.loading = false;
toast.showToast('Could not save post. Please try again later', 5000);
});
}
};
$scope.setFile = function (element) {
return imgPreview.preview(element, $scope);
};
$scope.activateUpload = function () {
return imgPreview.activateUpload('uploadImage');
}
}]);
'use strict';
app.controller('Page404Controller', ['$scope', '$location', '$window', function ($scope, $location, $window) {
$scope.goHome = function () {
$location.path('/');
$window.location.reload();
}
}]);
'use strict';
app.controller('PostController', ['$scope', '$location', 'sharedPost', 'addComment', '$mdDialog', 'goTo', 'postService',
'toast', '$cookies', function ($scope, $location, sharedPost, addComment, $mdDialog, goTo, postService, toast, $cookies) {
$scope.favorite = function (post) {
var user = $cookies.getObject('current_user');
// Allow to favorite a post only if user is logged in
if (user) {
postService.favorite(post)
.then(function success(response) {
angular.extend(post, response.data.post);
},
function error(response) {
toast.showToast('Server error. Please try again later', 5000);
console.log('Couldn\'t favorite a post', response);
}
)
}
};
$scope.hasFavorited = function (post) {
return postService.checkFav(post);
};
$scope.editPost = function (post) {
sharedPost.post = post;
$location.path('/edit');
};
$scope.publishPost = function (ev, post) {
post.public = true;
postService.editPost(null, post)
.then(function (response) {
angular.extend(post, response.data.post);
}, function () {
toast.showToast('Server error. Please try again later', 5000);
});
};
$scope.unpublishPost = function (ev, post) {
postService.unpublish(ev, post)
.then(function (response) {
angular.extend(post, response.data.post);
});
};
// Show modal to ask for confirmation of post deletion
$scope.showConfirm = function (ev, postId) {
postService.delete(ev, postId)
.then(function () {
// if there's posts array, we're in the post list controller or user posts controller and have to update the list
if ($scope.posts) {
for (var i = 0; i < $scope.posts.length; i++) {
if ($scope.posts[i].id === postId) {
$scope.posts.splice(i, 1);
}
}
// Else just redirect to /posts
} else {
$location.path('/posts');
}
})
};
$scope.addComment = function (post) {
var self = this;
addComment.add(self.comment, post.id)
.then(function success(response) {
self.comment = '';
angular.extend(post.comments, response.data.comments);
}, function error() {
toast.showToast('Server error. Please try again later', 5000);
});
};
$scope.gotoComments = function (post) {
goTo.goTo(post, 'comments');
};
$scope.showAdvanced = function (ev, post) {
$mdDialog.show({
templateUrl: 'static/partials/user-list.html',
locals: {
post: post
},
controller: DialogController,
parent: angular.element(document.body),
targetEvent: ev,
clickOutsideToClose: true,
fullscreen: false
});
};
}
]);
function DialogController($scope, $mdDialog, post) {
$scope.cancel = function () {
$mdDialog.cancel();
};
$scope.post = post;
}
'use strict';
app.controller('PostDetailController', ['$scope', '$routeParams', 'postService', function ($scope, $routeParams, postService) {
$scope.page.loading = true;
$scope.post = {};
$scope.size = "lg";
postService.getPosts($routeParams.slug).then(function (response) {
$scope.post = response.data.post;
$scope.post.comments = response.data.comments;
$scope.page.loading = false;
},
function (response) {
console.log('Error:', response.status, response.statusText);
});
}]);
'use strict';
app.controller('PostListController', ['$scope', 'postService', 'goTo', '$mdDialog', 'toast',
function ($scope, postService, goTo, $mdDialog, toast) {
$scope.page.loading = true;
$scope.posts = [];
$scope.size = "sm"; // Set the last part of 'body-text-' class to sm i.e. 'small'
$scope.imageSrc = '';
postService.getPosts()
.then(function (response) {
$scope.posts = response.data.posts;
$scope.page.loading = false;
$scope.posts.forEach(function (el) {
el.date = new Date(el.date);
});
buildGridModel($scope.posts);
},
function (response) {
toast.showToast('Could not retrieve the posts. Please try again later', 5000);
});
// Build a grid of posts of various sizes
function buildGridModel(posts) {
var it, results = [];
for (var j = 0; j < posts.length; j++) {
it = posts[j];
it.span = {
row: randomSpan(),
col: randomSpan()
};
it.img = it.span.row === 2 ? 'img-lg' : 'img-sm';
it.para = it.span.col === 2 && it.span.row === 1 ? 'para-md' : it.span.col === 1 && it.span.row === 1 ? 'para-sm' : 'para-lg';
results.push(it);
}
return posts;
}
// Get a random number for spans
function randomSpan() {
var r = Math.random();
if (r < 0.7) {
return 1;
} else {
return 2;
}
}
$scope.favorite = function (post) {
postService.favorite(post)
.then(function success(response) {
angular.extend(post, response.data.post);
},
function error() {
toast.showToast('Server error. Please try again later', 5000);
}
)
};
$scope.hasFavorited = function (post) {
return postService.checkFav(post);
};
$scope.showAdvanced = function (ev, post) {
$mdDialog.show({
templateUrl: 'static/partials/user-list.html',
locals: {
post: post
},
controller: DialogController,
parent: angular.element(document.body),
targetEvent: ev,
clickOutsideToClose: true,
fullscreen: false
});
};
$scope.gotoComments = function (post) {
goTo.goTo(post, 'comments');
};
}]);
'use strict';
app.controller('UserController', ['$scope', 'userService', '$location', '$timeout', '$rootScope', '$cookies', 'imgPreview', 'toast',
function ($scope, userService, $location, $timeout, $rootScope, $cookies, imgPreview, toast) {
$scope.page.loading = false;
$scope.hasAccount = true;
$scope.changeForm = function () {
$scope.hasAccount = !$scope.hasAccount;
};
$scope.user = {
username: "",
email: "",
password: ""
};
$scope.register = function (form) {
var self = this;
/* Use logical and here to make sure the function executes only userForm is not undefined, preventing errors*/
$scope.changeUsername = function () {
self.userForm && self.userForm.username.$setValidity("userExists", true);
};
$scope.changeEmail = function () {
self.userForm && self.userForm.email.$setValidity("emailExists", true);
};
if (form.$valid) {
$scope.loading = true; // loading spinner
var file = self.myAva,
user = $scope.user;
userService.newUser(file, user)
.then(function success() {
$scope.loading = false;
toast.showToast('Successfully registered. Please log in with your details.', 1000).then(function () {
// Show log in form
$scope.hasAccount = true;
// Clear form for login in
$scope.user = {
username: "",
password: ""
};
})
}, function error(response) {
var userMessage = response.data.message;
$scope.loading = false;
if (userMessage) {
if (userMessage.split(' ')[0] === 'User') {
self.userForm.username.$setValidity("userExists", false);
} else if (userMessage.split(' ')[0] === 'Email') {
self.userForm.email.$setValidity("emailExists", false);
} else {
toast.showToast('Could not create user. Please try again later', 5000);
}
} else {
toast.showToast('Could not create user. Please try again later', 5000);
}
});
}
};
$scope.login = function (form) {
var self = this;
$scope.changeUsername = function () {
self.loginForm.username.$setValidity("userExists", true);
};
$scope.changePassword = function () {
self.loginForm.password.$setValidity("passwordIncorrect", true);
};
if (form.$valid) {
$scope.loading = true; // loading spinner
var user = $scope.user;
userService.login(user)
.then(function success(response) {
toast.showToast('Successfully logged in', 1000);
$scope.loading = false;
var u = response.data.user;
$cookies.putObject('current_user', u);
$location.path('/posts');
}, function error(response) {
$scope.loading = false;
$scope.userMessage = response.data.message;
if ($scope.userMessage === 'username') {
self.loginForm.username.$setValidity("userExists", false);
} else if ($scope.userMessage === 'password') {
self.loginForm.password.$setValidity("passwordIncorrect", false);
}
});
}
};
$scope.setFile = function (element) {
return imgPreview.preview(element, $scope);
};
$scope.activateUpload = function () {
return imgPreview.activateUpload('uploadAva');
}
}]);
'use strict';
app.controller('UserDetailsController', ['$scope', 'toast', 'userService', '$cookies', function ($scope, toast, userService, $cookies) {
$scope.currentUser = function () {
return $cookies.get('current_user');
};
/* Separate function to get user details to avoid loops with JSON.parse since
currentUser() is called constantly */
$scope.getUserDetails = function () {
if ($scope.currentUser()) {
return JSON.parse($scope.currentUser());
}
};
$scope.user = $scope.getUserDetails();
$scope.updateUser = function (form) {
var self = this;
$scope.change = function () {
self.userDetailsForm.password.$setValidity("passwordIncorrect", true);
};
if (form.$valid) {
$scope.loading = true; // loading spinner
var file = self.myAva,
user = $scope.user;
userService.update(file, user)
.then(function success(response) {
$scope.loading = false;
toast.showToast('Changes saved', 1000).then(function () {
var u = response.data.user;
$cookies.putObject('current_user', u);
});
}, function error(response) {
$scope.loading = false;
$scope.message = response.data.message;
if ($scope.message === 'password') {
self.userDetailsForm.password.$setValidity("passwordIncorrect", false);
} else {
toast.showToast('Could not save changes. Please try again later', 3000);
}
});
}
};
}]);
'use strict';
app.controller('UserPostsController', ['$scope', 'userService', '$cookies', 'toast',
function ($scope, userService, $cookies, toast) {
$scope.size = "sm";
$scope.page.loading = true;
$scope.imageSrc = '';
userService.getPosts($cookies.getObject('current_user').username)
.then(function (response) {
$scope.posts = response.data.posts;
$scope.page.loading = false;
},
function (response) {
$scope.page.loading = false;
toast.showToast('Could not get data from the server. Please try again later', 5000);
console.log('Error:', response.status, response.statusText);
});
}]);
'use strict';
app.controller('UserProfileController', ['userService', '$routeParams', '$scope', 'toast',
function (userService, $routeParams, $scope, toast) {
$scope.size = "sm";
$scope.user = {};
$scope.imageSrc = '';
userService.getDetails($routeParams.user)
.then(function (response) {
$scope.user = response.data.user;
$scope.user.favs = response.data.favs;
}, function (response) {
toast.showToast('Could not get data from the server. Please try again later', 5000);
});
userService.getPosts($routeParams.user)
.then(function (response) {
$scope.posts = response.data.posts;
$scope.page.loading = false;
},
function (response) {
$scope.page.loading = false;
toast.showToast('Could not get data from the server. Please try again later', 5000);
});
}]);
//# sourceMappingURL=maps/main.js.map |
define(['commondep', 'plugindep-2.0'], function(cd, pld) {
var exports = {};
function init() {
cd.showAboutBox(pld.name, pld.version);
}
exports.init = init;
return exports;
});
|
jQuery("#simulation")
.on("click", ".s-de173d30-80d5-4d0e-841f-c319c16877bd .click", function(event, data) {
var jEvent, jFirer, cases;
if(data === undefined) { data = event; }
jEvent = jimEvent(event);
jFirer = jEvent.getEventFirer();
if(jFirer.is("#s-Label_85")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimNavigation",
"parameter": {
"target": "screens/d12245cc-1680-458d-89dd-4f0d7fb22724"
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
} else if(jFirer.is("#s-Image_92")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimNavigation",
"parameter": {
"target": "screens/f6ba56a0-98f3-401c-94b3-2c150fe5556a"
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
} else if(jFirer.is("#s-Rectangle_3")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimNavigation",
"parameter": {
"target": "screens/ececcb85-da50-4dba-8eaf-628779a62dcc"
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
} else if(jFirer.is("#s-Rectangle_4")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimNavigation",
"parameter": {
"target": "screens/3d3a7e46-38ef-450e-ad9d-6924ffe2ef7b"
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
}
})
.on("pageload", ".s-de173d30-80d5-4d0e-841f-c319c16877bd .pageload", function(event, data) {
var jEvent, jFirer, cases;
if(data === undefined) { data = event; }
jEvent = jimEvent(event);
jFirer = jEvent.getEventFirer();
if(jFirer.is("#s-Label_5")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimSetValue",
"parameter": {
"target": "#s-Label_5",
"value": {
"action": "jimConcat",
"parameter": [ {
"action": "jimSubstring",
"parameter": [ {
"action": "jimSystemTime"
},"0","5" ]
}," PM" ]
}
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
}
})
.on("focusin", ".s-de173d30-80d5-4d0e-841f-c319c16877bd .focusin", function(event, data) {
var jEvent, jFirer, cases;
if(data === undefined) { data = event; }
jEvent = jimEvent(event);
jFirer = jEvent.getEventFirer();
if(jFirer.is("#s-Input_6")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimMove",
"parameter": {
"target": "#s-Image_97",
"type": "movetoposition",
"containment": false,
"top": 7,
"left": 8
}
},
{
"action": "jimChangeStyle",
"parameter": [ {
"#s-de173d30-80d5-4d0e-841f-c319c16877bd #s-Input_6 .valign": {
"attributes": {
"vertical-align": "middle",
"line-height": "11pt"
}
}
},{
"#s-de173d30-80d5-4d0e-841f-c319c16877bd #s-Input_6 input": {
"attributes": {
"color": "#C0C0C0",
"text-align": "left",
"text-decoration": "none",
"font-family": "Arial,Arial",
"font-size": "11pt",
"font-style": "normal",
"font-weight": "400"
}
}
} ]
},
{
"action": "jimSetValue",
"parameter": {
"target": "#s-Input_6",
"value": ""
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
}
})
.on("focusout", ".s-de173d30-80d5-4d0e-841f-c319c16877bd .focusout", function(event, data) {
var jEvent, jFirer, cases;
if(data === undefined) { data = event; }
jEvent = jimEvent(event);
jFirer = jEvent.getEventFirer();
if(jFirer.is("#s-Input_6")) {
cases = [
{
"blocks": [
{
"actions": [
{
"action": "jimChangeStyle",
"parameter": [ {
"#s-de173d30-80d5-4d0e-841f-c319c16877bd #s-Input_6 .valign": {
"attributes": {
"vertical-align": "middle",
"line-height": "11pt"
}
}
},{
"#s-de173d30-80d5-4d0e-841f-c319c16877bd #s-Input_6 input": {
"attributes": {
"color": "#C0C0C0",
"text-align": "center",
"text-decoration": "none",
"font-family": "Arial,Arial",
"font-size": "11pt",
"font-style": "normal",
"font-weight": "400"
}
}
} ]
},
{
"action": "jimSetValue",
"parameter": {
"target": "#s-Input_6",
"value": "Search"
}
},
{
"action": "jimMove",
"parameter": {
"target": "#s-Image_97",
"type": "movetoposition",
"containment": false,
"top": 7,
"left": 122
}
}
]
}
]
}
];
event.data = data;
jEvent.launchCases(cases);
}
}); |
'use strict';
var nextTick = require('just-next-tick');
var toStr = Object.prototype.toString;
var isFunction = function (value) {
return toStr.call(value) === '[object Function]';
};
/*
* Big Integer Minimum
*
* Pass in two strings that are otherwise valid integers, positive or negative.
* No leading zeroes.
*/
var digits = /^-?[0-9]+$/;
var leadingZeroes = /^-?0+[^0]+$/;
var bigIntegerMin = function bigIntegerMinimum(numberA, numberB) {
var aNegative = numberA.charAt(0) === '-';
var bNegative = numberB.charAt(0) === '-';
var bothNegative = aNegative && bNegative;
var smallest = numberA;
if (numberA !== numberB) {
var lengthA = numberA.length;
var lengthB = numberB.length;
if (bothNegative) {
if (lengthA < lengthB) {
// negative number with the most digits is smallest
smallest = numberB;
} else if (lengthA === lengthB) {
// lengths are the same; both negative
smallest = numberA < numberB ? numberB : numberA;
}
} else if (aNegative || bNegative) {
// signs are different
if (bNegative) {
smallest = numberB;
}
} else if (lengthA > lengthB) { // both positive
// positive number with the least digits is smallest
smallest = numberB;
} else if (lengthA === lengthB) {
// lengths are the same; both positive
smallest = numberA < numberB ? numberA : numberB;
}
}
return smallest;
};
var dispatcher = function (numberA, numberB, callback) {
if (typeof numberA !== 'string' || typeof numberB !== 'string') {
throw new TypeError('both arguments must be strings');
} else if (!digits.test(numberA) || !digits.test(numberB)) {
throw new TypeError('both strings must be valid positive, negative, or zero integers');
} else if (leadingZeroes.test(numberA) || leadingZeroes.test(numberB)) {
throw new TypeError('both strings must have no leading zeroes');
}
if (isFunction(callback)) {
return nextTick(function () {
callback(null, bigIntegerMin(numberA, numberB));
});
}
return bigIntegerMin(numberA, numberB);
};
dispatcher.method = bigIntegerMin;
module.exports = dispatcher;
|
/**
* There are feautures of two types:
* 1) features derived from real entities (Message etc.)
* 2) virtual features (Summary_Message etc.)
*
* This method returns the feature type as a string to be able to differentiate different types of features.
*/
export const _featureType = function (feature) {
return (typeof feature.properties !== 'undefined' && typeof feature.properties._featureType !== 'undefined') ? feature.properties._featureType : (feature.constructor.prototype.type.call(feature))._notEnhancedSimpleClassName();
};
/**
* Creates style module with concrete 'moduleId' that can later be included using <style include='module-id'></style> into shadow DOM of some target element.
*
* @param moduleId -- a name of style module being created
* @param styleStrings -- a couple of style strings to be cancatenated into the style module
*/
export const createStyleModule = function (moduleId, ...styleStrings) {
const styleElement = document.createElement('dom-module');
const concatenatedStyles = styleStrings.join('\n');
styleElement.innerHTML = `
<template>
<style>
${concatenatedStyles}
</style>
</template>
`;
styleElement.register(moduleId);
};
/**
* Fits all markers / layers into view by zooming and panning them in the map.
*
* @param map -- the map in which all features are about to be fitted
* @param markerClusterGroup -- default overlay for which the children will be fitted to bounds (non-ArcGIS GIS components)
* @param overlays -- all existing overlays for which the children will be fitted to bounds (ArcGIS GIS components)
*/
export const fitToBounds = function (map, markerClusterGroup, overlays) {
window.setTimeout(function () {
try {
map.fitBounds(markerClusterGroup.getBounds());
} catch (error) {
let bounds = null;
let processedArcGisOverlaysCount = 0;
let arcGisOverlaysCount = 0;
Object.values(overlays).forEach(overlay => {
if (overlay.query) {
if (map.hasLayer(overlay)) {
arcGisOverlaysCount++;
overlay.query().bounds(function (error, latlngbounds) {
if (bounds) {
bounds = bounds.extend(latlngbounds);
} else {
bounds = latlngbounds;
}
processedArcGisOverlaysCount++;
if (processedArcGisOverlaysCount === arcGisOverlaysCount) {
map.fitBounds(bounds);
}
});
}
}
});
}
}, 1);
} |
/*global require,define,angular*/
define('angular', [], function () {
'use strict';
return angular;
});
require.config({
paths: {
'angular-bootstrap': 'bower_components/angular-bootstrap/ui-bootstrap.min',
'angular-bootstrap-tpls': 'bower_components/angular-bootstrap/ui-bootstrap-tpls.min',
'angular-numeraljs': 'bower_components/angular-numeraljs/dist/angular-numeraljs',
'angular-resource': 'bower_components/angular-resource/angular-resource',
'angular-sanitize': 'bower_components/angular-sanitize/angular-sanitize',
'angular-ui-codemirror': 'bower_components/angular-ui-codemirror/ui-codemirror.min',
'angular-ui-router': 'bower_components/angular-ui-router/release/angular-ui-router',
'humane': 'bower_components/humane/humane',
'inflection': 'bower_components/inflection/inflection.min',
'lodash': 'bower_components/lodash/dist/lodash.min',
'ng-file-upload': 'bower_components/ng-file-upload/angular-file-upload',
'ngInflection': 'bower_components/ngInflection/ngInflection',
'nprogress': 'bower_components/nprogress/nprogress',
'numeral': 'bower_components/numeral/numeral',
'restangular': 'bower_components/restangular/dist/restangular',
'text' : 'bower_components/requirejs-text/text',
'textangular': 'bower_components/textAngular/dist/textAngular.min',
'CrudModule': 'ng-admin/Crud/CrudModule',
'papaparse': 'bower_components/papaparse/papaparse.min',
'MainModule': 'ng-admin/Main/MainModule',
'AdminDescription': '../../build/ng-admin-configuration'
},
shim: {
'papaparse': {
exports: 'Papa'
},
'restangular': {
deps: ['angular', 'lodash']
},
'angular-ui-router': {
deps: ['angular']
},
'angular-bootstrap': {
deps: ['angular']
},
'angular-bootstrap-tpls': {
deps: ['angular', 'angular-bootstrap']
}
}
});
define(function (require) {
'use strict';
var angular = require('angular');
require('MainModule');
require('CrudModule');
var AdminDescription = require('AdminDescription');
var factory = angular.module('AdminDescriptionModule', []);
factory.constant('AdminDescription', new AdminDescription());
var ngadmin = angular.module('ng-admin', ['main', 'crud', 'AdminDescriptionModule']);
ngadmin.config(['NgAdminConfigurationProvider', 'AdminDescription', function(NgAdminConfigurationProvider, AdminDescription) {
NgAdminConfigurationProvider.setAdminDescription(AdminDescription);
}]);
});
|
export function isCorrectSwipe(swipingDirection, absX, absY) {
return (swipingDirection === 'x' && absX > absY) || (swipingDirection === 'y' && absY > absX);
}
/**
* We need to use global document object to check whether DOM is focused.
*/
export function isFocused(element) {
/* eslint-disable no-undef */
return document.activeElement === element;
/* eslint-enable */
}
export function isTextSelected(element) {
if (element.selectionStart === undefined) {
return false;
}
return element.selectionStart !== element.selectionEnd;
}
|
import CaravanaList from './caravanas-list';
import CreateCaravana from './create-caravana';
import EditCaravana from './edit-caravana';
export {
CaravanaList,
CreateCaravana,
EditCaravana,
};
|
define(function() {
return window.isNaN;
}); |
import {fromJS} from 'immutable';
import {NavigationExperimental} from 'react-native';
import {isNumber} from 'lodash';
import AppStrings from '../../localization/appStrings';
const {StateUtils: NavigationStateUtils} = NavigationExperimental;
// Actions
const PUSH_ROUTE = 'NavigationState/PUSH_ROUTE';
const POP_ROUTE = 'NavigationState/POP_ROUTE';
const SWITCH_TAB = 'NavigationState/SWITCH_TAB';
export function switchTab(key) {
return {
type: SWITCH_TAB,
payload: key
};
}
// Action creators
export function pushRoute(route) {
return {
type: PUSH_ROUTE,
payload: route
};
}
export function popRoute() {
return {type: POP_ROUTE};
}
// reducers for tabs and scenes are separate
const initialState = fromJS({
tabs: {
index: 0,
routes: [
// {key: 'HomeTab', title: AppStrings.viewOneTabTitle},
{key: 'OffsetTab', title: AppStrings.viewTwoTabTitle},
{key: 'TravelTab', title: AppStrings.viewThreeTabTitle}
]
},
// Scenes for the `OffsetTab` tab.
OffsetTab: {
index: 0,
routes: [{key: 'Offset', title: AppStrings.viewTwoTitle}]
},
// Scenes for the `TravelTab` tab.
TravelTab: {
index: 0,
routes: [{key: 'Travel', title: AppStrings.viewThreeTitle}]
}
});
export default function NavigationReducer(state = initialState, action) {
switch (action.type) {
case PUSH_ROUTE: {
// Push a route into the scenes stack.
const route = action.payload;
const tabs = state.get('tabs');
const tabKey = tabs.getIn(['routes', tabs.get('index')]).get('key');
const scenes = state.get(tabKey).toJS();
let nextScenes;
// fixes issue #52
// the try/catch block prevents throwing an error when the route's key pushed
// was already present. This happens when the same route is pushed more than once.
try {
nextScenes = NavigationStateUtils.push(scenes, route);
} catch (e) {
nextScenes = scenes;
}
if (scenes !== nextScenes) {
return state.set(tabKey, fromJS(nextScenes));
}
return state;
}
case POP_ROUTE: {
// Pops a route from the scenes stack.
const tabs = state.get('tabs');
const tabKey = tabs.getIn(['routes', tabs.get('index')]).get('key');
const scenes = state.get(tabKey).toJS();
const nextScenes = NavigationStateUtils.pop(scenes);
if (scenes !== nextScenes) {
return state.set(tabKey, fromJS(nextScenes));
}
return state;
}
case SWITCH_TAB: {
// Switches the tab.
const tabs = state.get('tabs').toJS();
let nextTabs;
try {
nextTabs = isNumber(action.payload)
? NavigationStateUtils.jumpToIndex(tabs, action.payload)
: NavigationStateUtils.jumpTo(tabs, action.payload);
} catch (e) {
nextTabs = tabs;
}
if (tabs !== nextTabs) {
return state.set('tabs', fromJS(nextTabs));
}
return state;
}
default:
return state;
}
}
|
import { h } from 'omi';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(h(h.f, null, h("path", {
d: "M12 3c-.46 0-.93.04-1.4.14-2.76.53-4.96 2.76-5.48 5.52-.48 2.61.48 5.01 2.22 6.56.43.38.66.91.66 1.47V19c0 1.1.9 2 2 2h.28c.35.6.98 1 1.72 1s1.38-.4 1.72-1H14c1.1 0 2-.9 2-2v-2.31c0-.55.22-1.09.64-1.46C18.09 13.95 19 12.08 19 10c0-3.87-3.13-7-7-7zm2 14h-4v-1h4v1zm-4 2v-1h4v1h-4zm5.31-5.26c-.09.08-.16.18-.24.26H8.92c-.08-.09-.15-.19-.24-.27-1.32-1.18-1.91-2.94-1.59-4.7.36-1.94 1.96-3.55 3.89-3.93.34-.07.68-.1 1.02-.1 2.76 0 5 2.24 5 5 0 1.43-.61 2.79-1.69 3.74z"
}), h("path", {
d: "M11.5 11h1v3h-1z"
}), h("path", {
d: "M9.6724 9.5808l.7071-.707 2.1213 2.1212-.7071.7071z"
}), h("path", {
d: "M12.2081 11.7123l-.7071-.7071 2.1213-2.1213.7071.707z"
})), 'EmojiObjectsOutlined'); |
(function(angular) {
'use strict';
function ViewUserDetailModalController($state) {
var ctrl = this;
ctrl.userDetail = (ctrl.resolve && ctrl.resolve.details) || {};
ctrl.isDisabled = Object.keys(ctrl.userDetail).length > 0;
ctrl.init = function() {
}
ctrl.cancel = function() {
ctrl.modalInstance.close();
};
ctrl.init();
}
angular.module('viewUserDetailModal')
.component('viewUserDetailModal', {
templateUrl: 'warehouse/incoming/view-UserDetail-Modal/view-UserDetail-Modal.template.html',
controller: ['$state', ViewUserDetailModalController],
bindings: {
modalInstance: '<',
resolve: '<'
}
});
})(window.angular);
|
var LOADER_0143 = [
"E005000008D12FE75F7A8F6DC9",
"E0060000E8700FD503C165F942C1ABEA2D2EF0045A8223FD60CE37A0AED953BD3C6735355798088E3F116932517D32B51D3849FEEA605F2E31EB3B41C4BE39834129B875E945DBD2CBC45FC5870893940286BA8306028D2400999BD1F0203FDCB18378C9F179D90ABCA99160ED56C148E2D5747BCB3AE6EA4E50C5A775114BEA5CC0B7F818E9F31973565BB237E6041BE24ECC4BD42605FA3CF1820088CFDD01B95DC1EBBAC1D87D46B37DD18635992E51344B5C47B2A0376687945E110ABADC2A1E6FF75E4BED76B21A1CB02EE09DB091DFD3E84D0D99C6EA7658B717C133DCE02AF5E484A2B9421F27FD5CBE",
"E0060000E8CE25694A300EA686D563B5712A7F052D41D56F981BD03602A8824642675FC97C7BBF89E12FD2FA13895BA1891812C07AC5124995A8DF18165E38445E58B6E09C5B6AC3AD87260AAF8F64D2878D355100091F80F819C05E1422CF53F0277156A865BEA7BC1B26AD626E47B1C7DA8AC7B5BA93ADA3E337004372D0615EC956A2050D645AEB75A894FC3159078AE59BF496343C7F435E159314BB8A8726F3B9AFD14AB9DE4DA2E504A9EE96E87ED5A8C662D4786C8B8C6C55C54F01317047B70AE554F3EF5BC642174FD9CD8009DF9CEF627DF3A7F2FFFD229B2AAF4B7FC1107531303DAF8A8AB2C023",
"E0060000E8C527FF7CAB726AF8C4F9DBA29FABDB08EFD5B28CA50E3A67E9FAE2A8166F2106B3D0357DAE8E83102D5F10F53B7A9EDC0F132C7E3561D575469EC6E70074F5A29145751BABF6F3320440093E79A14020A6CB27B3790992B66288CC5751D9185FE2ED901C4527E12835CCBB4BE459067A584464D19705674BB77F3606689D3E38858DD99B9558B9D224B131ACD525DCF000417C9D931273C163A1CC969A7BBD6E724595D1FC6EAA90E28B638585F03E017D860433356CF4E316FDD412BD37BA75B2013E9D2262774124DB7F6225FDB845A5D97CA0925E91284C9E74EB4B4D791B4BAAB2D2312F2D02",
"E0060000E886083A401E97D4FDC5527DDDABEEF02EB9050E1FCE5680A0FC8B34E661809DBF5F4BC907A4889F64C6C19D30BFA514A2812B4354823A04C50B2B38B8023D377B18C673CF4528C072108F773285B3E04930B70E51D79374C3ACE74B144482D4E9622BE2EAA843AAEEC6F78EE448455C1E748AA06F556F70FF674E5E9D2DC1CD98E8652015085B2EB3CA093E6EDCA001BEEC747E283F20ECAA29D714DF093A127AB8436E25E0EF30DED7142502608D3DA823B70CA09E3109584FE3783B87F733A776D4D49DC0B51CB945DF43614B0E8404BEF436EC39E5F0718E87DC9B2309DF1C546FBFC80C5AD9FF",
"E0060000E8C3560AEE64729A376E61C0FFC8521C569B67CE60520207EA92555F751DD3DF8F2C14F6D96B8DBDB621F7AE1C5E9CCA88F137FF84272A1D76AE32122D295A2D18722B2D854E4A3E54047679A6BDF3BE093F5C52FD1539CBABF896578B6008469BCCCF17BAC0CF82A389E59D23032D61E7AB7CE6AF7510E2BBC5F3113C9DCA1CFCED36E9E2AB096CB08C6F336A94D62A441B4641F8FF16CFFE7DA1F96F9F877366A563C1E784A83C2F796C59E6050086F52FE6F0938929E392CF272D1748271A17F927A3B633CDA5FC78196DAC3AEA3CD2B8B95E7A999DFDF5F8D51FFB634FA606B54163D2D075895A",
"E0060000E89E899A179127AD6B3EC893132400460513F72512E860421B2E2B7FE82989D9A982762C1B821D63B2FFC54B1074B7BC3880981EDCF185B875DA773E41D53E6362E2F9B5F56C80621D2BB9AF81F3B6C3D272211343233D6FDB20EB06C8C065B2AE6B5A597125DE9F512274426D8DD7B51E68F69DB36A9D8C778664BBB2C70952C1B9FBFA885F02872C626E3DF7E59890281A76BBC1D89EE06500D0AB1C215232A0B68BC3CAB0579E64F7BBEDCC81ABFFC0146157980CE2A3089E089109A0289C22B952FE51D7CDA3798960978E232A90280D65E00CF26ABA602422CB8A57D1D3CC715787F55DE1A240",
"E0060000E83F7CAF3AE51FD369F22C049FFAEA280CC4632F255458024D42FB4633C2BC5349A8454A46A5B0E2275751D97B1DE1A63F5829D50FD2ABD0F9DE42C007A776695C81BE5144171B5F8BACDD4381C9BB71046849716C9449132B2829DFFB9CE6C14807BDB9F715D66BF60CB473F73F56849EF82B454679A5B17CFE50E69856B3A8411EAB338EAA8FCE36D7D95A1589DEF4B015E223EAEFEC48BDCF8FB36327B2A47F4FAF8638353C0FBD76672CA714579AEE71727C36A3380D177B4D51BBF6D79A2EA6003F23487F323820D77ECD87795B2A5167DE95C7C43C78FA1D9EFF982419EB7596FA8B6AA354CA",
"E0060000E8238050BDA888CD3DD7E92416DC815C578C2F8EBB1E3A5D65553EB66C4A3666A918F958F64AAF8727CD98DC997050938E5597EF65B45EA7D58F1881E1823C92B008F0015835B0A5AC89228E63C6E872F91867BC318908931789748ADD78BD2CD0590F006F9BAC625F46910E7522E37356853943A79753575F38570EA1F3AF3DFD243B04EEB66C9B24C70312CC3985C73327368BFFD54F1B6EA90F4BCD684C22D0B2FC6F9A344800258BFA591687FEC62EDCA2D756AA2911E34825BDB89A13166CC07FA9684456932C83174431D6639A47972DAA0B1E84BF503729EC809C0B30C8182FD2E022DAB99E",
"E0060000E87F06D9775F7936F0DAF309ECEB241B00620EEDD0B57E88D0CA2D0F9D94022D6514FD2B62A26759E99FDCC3C95E488DC60713070DB11D8EC52D3D111917C589B347E0C52BE1EFECBB404F3393F129EB947464C4876CD23D338C4157FD300F2485C4473EC16A74316E4DAF46523DE5435C5369BF5A1BFEEAA972B9B95F730394FF8085F5E2CE762677751D2E1EBA54A1F5EB5994EF7A69458F39E21A2CAC7256FCCD581125DEABE1C48FE5DC42064B0409895583C7847FB4B7162630D334EF2B7BB0841F6D846A0CCE614B40F5BC6504D5A5CCDFFB92EFA26BAABEC7BCC6A633AD8D64F51AFFCC9B6B",
"E00600002882ECEEEE076EBCDB59B4C68B4659DFAA1A84009F193461A1965EE68659F73BC59F99440A2D362102",
"E007000000",
"E0080000087BABE668DED20E16",
"E005000008CA53929C24970996",
"E0060000E8D6E6B8D30D80D59FA9B95EEEC6077E358CFB4638FA3C1D3BD3C06A48912E661D309DB038DECC7349EF882FC677B1B68FCB0061200D170F3B91040B1824C98CF509FE3E0A93AE22C64A063A61C76F04AFBCAEE8D1C67166D194C3CD10384AEF7B1199111E1550AD4586AA20F063182CADFD509558942F67538361B9D9A3F096A00F3E0DE891BB3274D023489FE793A61BC86394CE19F3184D46474BD2F3B46D988ECF0C69EABB6B2BAE38F9962B133DF70E55B1DA858864376707474419D3715B817E4E174F24CBA444CDE1A9182474128E473CCCB9C566EA388DB2CE866D1B3A6CDAA6A046FED385",
"E0060000E85E62AA77F889EE5E27820220AB934FCFE3AA0D52EF5508968F156024FE48D42C8A415063FC08C70C525B4F900726B9389BC16065453DF9E94E312818BEB39FB50814216B14379C830CBF495E5115D802E2CC899B8D925EDD651F2174B7D947CBE8EBDFD4A61325A27600CC96CEE807CCCE0E7A03A71AC1385F3031654E490ABA2F04E9F021E75359D7408024A315E5C956FCB740AA2690AB006BDDF0D77F152CF35123D05D68D8982DCAA320BD679B0F7CF765B8E0054D23BE51E137A407457F90794BCDB26A8585AB5449AC93CE770BACB312CCC86C76B0D8BD2BC5021F16B82D66808A8FF67874",
"E0060000E8A0CB7DD53C3C2BA5200B4FA21A4051B4D736B0C8C63D23E770EF8E2B48C468C772A183AB655C7BE9813EA53177F4C8DD5AB2EE96A364196F6A3516072743DF3217B1C2496383B5365472EDEE8E65D65D02D116E625FE7F293B8B610CCB38FBC0FC9FEB52A34507CF27A6F6B0D8577CB941F109BF27F2EDA2A5FC26E3076485E631A22EEA64659E287FFBAC4680524B0A623E91D4659F26E76E5A08AA0FB55386FD7F116BCC0A03920251489E453A3D5391A74977B963F414A0C5EEBA391C86338FDC2B1D6ADCE3A91843DECDA080C66129D0C417B79A907239F24E84414744BE7FCB8E921C7F867D",
"E0060000E8EB9691BDDFE6AC0BAF6A81F440E1450505256C464E367AFCEEA5B7B5C55BF603F136F4665830DD1D11289CE6C5B5BD738EE0ACC75D7131E6CDCCDB25D867F31BA4F4E57A6A975DFA88B546B1B48DDDA079CC1E948DB50F2FE0A22C6C3D05FE90E0BD58DFA5A9C58A774891421F50F90421DCCB2B40408147A7545FE7B7DE7BF866F6DE4239231989407F22411DE8BCE46C3C6B932635DE2D550D3E055018EA2B9DA5E8A7CD002EB82A043803440498DD760EEE59326504EA51336DFDC8F17D3E573041596E7C15111771946CE629E84E72EDC8469851D7DFF7529BEBB93561E613F4AB1E25C4664B",
"E0060000E890D1063F4FEB79F390A16181CA267908ACC4EC7A8AEF7B37F0EC3A024EBF836DA681D75D77BED9956AC6D189F74E17B355DC6FE248ACF696BE5CE4A4DB273B192E7F3C2F8BC861D6AC3E4CB698FC3783F2E13AE90C0592235E99037EB97BA1310323A9021CDD9E7F67001851973E9558405BDDF1298AE0D26B9321BCED46D26EAB8D26AA0C14D7DEC645E66800E111C718161732AC973906FBFA18EE4A114FC239A14885CF4CC11FE17F79E909F0148A0490773AF85BE24F66A25554FF87D6469FAF957ABA081323B11AE4C0E1722F87BB8D5A446A7AF2684CBC4CF0721DDEEC9A805BBED6FBDA64",
"E0060000E84C1A414FF3769CDDE33AE8106D9B9A63FF80F111E1770EFE8021387A839957069EEB92B85C7D0EA91B95064920F7902AA8D6542E8C50E26E7ED5F6491F9E5C9D8A7EA49373EE1B20D0851BFD3E8FB3AEE746F3F371F974423C9319EBF02422816373651E9C471BCAEBED5749EAEAA9F011B3B9CCE62C53CF314EB26C146B65B2EE11B286DE75EEF197F042EDF5433DE9F974A385B2C8484B153C6C6AA065930B313E8787941223AC9B07398BFD0503F22637E56FBFBDF1DE66FC2B76A1413E406F0F71F66498AF74AAD6F46888FE2F7C0155B195D92C6EBCDC1E7BE35151EF469D81F32FE789CF83",
"E0060000E8094A11B4B29FBB6FC84BB81B63536FAC62B8DCADF92EFE1C7937E644AAAC20566F202FD933F796229D8F39B1EC976C88739B7F5AC16DD3E9076528C52E754B93E2651B3853C0929469FC46B179A43D863DAB3AF208C8D05E151186E5763C132A466294E986206A1EE5B502DAB56633B2031BC5A4A473F9D545A158C005E4509836F38FED322A6DF7F86B9F5EA643ED8A7BD231E9581F95B677C67E9AFF80AF246F40AA64ED6FE456645359C9B13E23F4008613248E9548962E7EE1D99AC70734837E8468B59EEBA956E497F61F4DE2AD30555524863979FEFEC6C69501EAAB3DD129A8893C02C98E",
"E0060000E8B52CCD9F7D8D5D6AE18C2DCAEDA362A2296478BEB842C22B20E7A7A1F637CA8C34C0B064405D1C250D40BE47483365C1A78064A554BAD4879D043F19944B6D22924128887959BD67A114E135175CF4AECD9FAAA581F918BB4F179E3F6103BF1384445880ECE02F88F39587908BFB18816097884AD610A04A3B542F31A2CA2A4354395F6FFF90F05ED71E6CA56A4056AA781A15979192AF35D64A3507AC35AEB9298A8172F9A2CB2346A2D818398AB5E45088D20F267478A4C2D73A017A0CFD51B69F751DE9B1C29B23C19781C4ADFF9703B79E0AB3992A08345FD2B95DA1725D9A3DA71AA45B1415",
"E0060000E81175E8CEB89C12BB2846CAF3D29239ED80AFB6990CA30E98DA6716D04149EC25D4A06BA145698A1EF994A8FB1A9043794EB198B45DDFC4A0CCFE620DD53C44E460ECFEFFF120F65C71FDB7C46E211E19618AB4A6157AA0319BFB1EFA72C5C748DCEAAA8F8A64DFDBF45C879AA63C4861FEA54D9A1B8A2F7218286A034127618662D69A04B1521AC82C38F5D321AAFADBA586E4960A5146BA01B16B570F2F9E689452C55CD88DDC1D071F9E49DD4CDAF3E2D41A4377824C56F9D76588D67C05707B98987978C8C7360AB740382563CC8EB8BF3E4829E429DE7ECC662A3E08A90905B7B4DB9F8ED89C",
"E0060000E80640A382F4026E7137414BD2C2E383430B7197E863EA39C05FB7D02830CB744E8AD43AD41F75D60452A5F35A252D3D5C021CC0D74DBF72D365F744C2D770F09FE04E84284B66AC3B89D1A67261644D5D94B4497E4755F1DB2DF8349C591DEADB5E91319B6BC0DD6D7A22A96FAF1C68E41003BD016122D020E1A9D2370A267A45C1A4BD76221059596AEFD20A1C47AED888E7D4970D837411B10DCB036004ED0E9AB1CFF3415769208E98FD856FCC62A8EACB9A01C3C7A74319FF157BC5252667C8D3CFC92DD959962E4941EB0B0CD45E45EF504BF49A663D788F272E9A2AF20E6C65E026D2C776A8",
"E0060000E83B9AA4B40D76F94C0066B4AA6F0FD5091B92B81E9421356865FA5FC484FA28051239AA0C65C1CE423F41DEBE2B6B2356461029E6046609D4F7AD7E1CCF45357CCE87E40547125657BBE178F01EB7360642429BD26513110A0E09E2B140411AE80AC0A2C9F2DA7839CABE15F39838BDDDA10DF6956ED538E378010B359EE9F5EE861DA55B63B11F8D31361C5B7FB41B860B8264BFBA92356B9F751AD972612907F0F7BD5B11F0A78E08C0F19448E409F3097EA2ED47AFABAA74E6F16271135C805D3729456493C11E2ED6912BB8722A355EB905B9EB876F02D5081876BFACC8009408BF235D0EEFF1",
"E0060000E8828887879070651039FD38B7E769CD28DD2B756335EB1ADD9CF585BB057EAA68F13F97DE4EA8633AB4547BB231388B42CC5C765AF48731BA381736F99C3979266302B2BE4139DB8E402755913327189645593B4466CE9D54453F163C6EB6DABBE2C2F2F1E858FD9B23F5974E5ED4D11F7363698B497CE9FB7F444F78A343308DA2B38F1456991A64E0987F31B5E5370305087D516CE051884B75D91D03AA99D902C0429C26C456BF8B028BA745CE7CD3CA2DCC7DE11F6CEF4687B58EC400C8F8FC301FDD143BC10EA5BD972B63761237B4A2ED0EA12431ADEE79CB0E32FA99C5C683E9548EE99E8A",
"E0060000E88ED17B8478D5FCE22C9493B636FCA43B2EEA1C30D3FC6BA63D56914E3D6DF2FEDB05B592CA64F6AE380B5C1C24CE5AE263D7C2366AB52E0156D6EFA10C10A7A2ED1E71EED52462177DB0208A15370B73EA97BCF1AF55A62C6CEA5B39C4FF8DD04D5824EF75E37D58F62904B97B7065C2925B53CF476A97FE34BC2492046D5E5B647AD9B1D3DEE0C5CCEE63CB45EBA202C94BD032950DCE5260D7A83AB1750865B60E9E806E60EA4FA588E67B63029CD7A11D38376A47905D118C8E60AD6F5E5D469E179BE5E187A70C5ECE9A62543CFCE64220C83ADBBC3EE0613A5BDDE6041940910FCEBA2950F5",
"E0060000E86D8D6772187C36259E8EB2248F34AEFA700BAA5C6180B5B9837EA2E48DD4555DC80229D4ACA1328BB16A2D84CD4FE8C255C1797FFAF013B89BE95FC224CE2C0E34E6CDA6EC1E7C6946B1AE0C9F2E9C6B163C7BDA18D6285C1928D6BFBCAF3FEB291DEF68D798574D656E0BDFBAB89AF2BCCAA63CBB6534409752F81F32FE9768E81952900EB0A4B4ABC3F6B67FE053442A6D8EB9DAC3358878AEF5A44AEC60A0E06CD597337146F8EA5715247B68B3436DB990CCB17BB69A5B3E4BC2527933DFC594523D56353509E8FDBC9F4B18FE486D8197D2EF83AB06033861138306FE956221DA03068794C8",
"E0060000E8AD49552D7B95483048FD345FF95B7C24D6DE5C307F4E04FD9BABCAE9D3841F3163CFA0FBE700A2F8DE1A1789202A5CAE4CA993AF9982889F54BC4067F814BA814573456262B8871E04F4D9A92C8947C77B12B661589C1215E4DCB4883321AE46044E688007EAB7047A950D36C898B0CDCC8C64F553516081A6523E8437DCD4BE2C47C402A8BE0E160997279A7078C538F0CB9618739EFF4763CC5EF7B5617723BB93981833F37A31A1A1B4F5A6661158D4A185A53A8BBA91FC67FD9B2A189DE04CC6114ADD17561EBD7097EF4AAC16FE37309B70F82B43C5FE22412440772A18DA9AB221F1A6D9D7",
"E0060000E8FB71F8BCF9339F2B9E8AA44DDF833FE76A098A3DB8BD90DE6D2C5D71E872A77045B329B2EB96D3675D3ADC2C8207E2E038FCB060877BF69C8D7CA498C20B764F8ADF248A12F3F99427726328B4104CA2ACCABD2DBE64CC72CEF805A4AF4966953D7BC0E5EDEE7D46B48F89337141AB2137D32B5ADBCD334D6A40225F7F76C92BA32F27CB80CBB096AFBD82A3015DC0F8CBAF5879C3723C4435A0823A82CAD45B0D4DC0F1D957463EE5F279094C41F2E3FE52D4616A30ECE778DC75DACFB8EFE73180054DAC92438BE9A889E7310D218F73370343C3B25B8B0C55BEBFF368BD842B450C13AA972055",
"E0060000E83F0181F527D2BE0C30031F8C348CF5BDA42C3945AF7029829900529BED90A3D1F924270D1CA5B91D1DA4B5C5D3EDA1C89C4BE51C89894EE1423FA876E5056725A45223D298B357546FC0405E9AF4827E019974C9DF1F63A44D3E23D03665EA480114CF83CFD38B5FFED2739674A8CD68790A9A50BF463FCCABA910B96305D6ABFE96CD2668DB281002360326CE029307AD30E9B8B5A0F1230B34D9BC7D41990CAD87EF4003CFB05CD47D99C54F34E9029E2CA3E7EEF8DB3416D9F9DECC3E27D1BCF4491088E22C61ADB2717DDA3BE5331C91EAF2D0AAF7ECB7AEDDA7537831EB38AAE98E6FCC61F6",
"E0060000E8A10B7B7FF9D0C5E84FD15BB0AE35099728BA45D93328E97D7176B4C4B4FD33FCBC38951775CA8EBB7237ECCED7BE849501BA5258973EE06B797CADC12A105D253023207B3FE7C4C17F3EC013B53A53684FD3E4B179F6A74AA68F7FFB3B89525574064BDCD472E03C75D25C216F43F2055CD9FA7186451D55D6909519592A98BA1B71CBA571159CCB455F73ACF97F0716C2075A77B50FEFE41B7E8340E21DDDC724F1077A64FD71A7B0B292B8BB75942EF804CDA3B721B9CD816A96E4BEAFC43597831F8E15E3BADD807D75A91C1C96268FC10307BEA15DF80B88390CE8636032D8964149D1BBBFDB",
"E0060000E8CF002C767FDC0430A9C313181D4E201976F9FD1A403FCD7C78568D63DD4FA1E802D11C4F1CD620DCD81E065C9B6D92BC78DADA4C54476A4E17BE272AB47F8D4FAAE9EB768FC482F36BA5FC8C1D468C5564584CDBE0839C8D007BEBE4D856346EEF81B0E52D367F27300CF896F6F83D2EE4111A94EF20E17727C31061A0D845C92B48EB2F931CDB5E79AE88687A47EB065E292DA2EED501915841D0D59B2E3E24C3DBD50734B8C0A8F65502C708A9CDC6FD6BAD8C3E01A0DD3FB312F5C0D805F50E21C153458C3ECFB72F8838F13D58097498352A8017CA76FF8E1906FD80E2ADCFAA1E38DB35AB32",
"E0060000E83A29DCC9262A1D217CE5481FAAB6C3FC2F4AD2D83B9F773F18C64D07BE14B46F82A23EA7C6B9E5F6E2912FEB81A9045C018737C31297A348F02C6EC47E553374C390D61907ABFA7BD00CCFFDA0B976766626E706DD3D1D3003E125E7F8A95843A9491881FE0230E3F3016FFF607F2915056A79079C13CDBFA1A2A0B62981CD973E7F8FA2DFA1F5CF57A422F8631488A34261E7D498824B7F8881FC15D82A100E94A31138FCD74C4811548198CBF60F9223A7BEDB560EA37B5A02E7425FE45B2AEBE483A45195DA53D2B8F44DF65F8CC630A0F8065440B5B29C7A2B92E91D0E015F6CD46F0F5261A9",
"E0060000E887D30F586E7F361B359B01259FD73BC50EA236096034BE3B2E867E4E09903C6CE498BE8EEA9EF884CB3C3CE25AE815373F7B0B024409278312990A18AB470744FCA60D19E5B35B43F06C90176E1E71CD5BD60AD6EEBDF90759E7EDEA271467DDA72AB7F58AF48245E29EA3AD4645CBA4217CA5DBFB5970D4D8E02D35732E84209F92369A9DB0AF014CAA08BD2A2F017A94A91343033CB3CF32F6F354635F119BCCE2E97F6DF29543F2112E2D123B8669FFC87F276F1DDA2E85692D127EE8D615929D2F548EBC554DE6FA470B53421BE81B32C52BE8C7E2C57EB5DB87C8AB4FFDEAD7582383CD2E9C",
"E0060000E87F37F330DB52AD372403EAD9301FEF4C305D62FEC7E7364482E87C36F0CC430B5044433CBED6C847A439607C9B959A1D44AAE8FAC4601C25AB3C9575CDEED49EB45DD57B4EDC184917B1D66A1445E44416EC7D9D83869DFA9F8D94B1362D9981F0C07ED0A9048A391E228E2E1B25EC2A066DF8575A55D92C1C52B35DE221EA2AC5F663045E99F8BA2FFB003F32E8B7E83C06FF9F93249AF2C9FA98B194CA31495DAC2E5E8106C5205FDF58C00B0954CB38647D7926985A5CE124F284D6A6FEA4E1F12805DC085888942E6083C51D72E2D08174EC1442B9CEA3D64F8CC4F5083DC46A764983B795CB",
"E0060000E8B3287D479A0E0DCF4D584C88DF348ACB65DEC804227BC891E2B8F0B01FAE080889C7A8B8DC16EF23854474CE7A6910BDC69202526BA6A9A5DAB1C9BFF054D8DBE0D26F49446E2168B6393D677E685AEFC1ABEA320031AD16E9ED439BA1A921F30B6480B879D40FEFB60EEED55D16B72BFFF65ABB0D0365ACA660AC15544736B5A86E1D1A44624EF4570AF7531F34C2C0A46240D1F1C8692641C4556BBBC8E042C4648706AE04BB0A71D7F35978C5D68A47922F273BC79E99E0C9996598722DA0B7540EEAA0CCC02AF019979C4EBFBD05E351458CA3B2D84F9BA323D4906AA5E62A73F6FB6EE36FEF",
"E0060000E85C15A29CBC138A8FEBF9CBD95DA4A42A63018894B73328F80C178F90C1B0069BF16B914FA3CD6105B469F158B874152A08673090F663DE79112436CC2482E74095797E0E94F8A3E20C176C1DD0883AB77379C131F1EB66162D3F617BF24C27E2D99B841FCA77B91F9457A12F5CD3F5AA7C872377CB667AC83AE7EEB0F654447FA127F8508B2DF43E708EE246941F1A5E47FA797C13041722F1B2C2E82B905E7E02B6C55B2A1E07BF6DE25A446DF288810EAA3444BC27A5D58734E7715E661EF1DD546558F5C4ABF6790C35B8BE4B28946D4BFCCF213128B740010A698C418ADDFCEC0E374ACEC419",
"E0060000E85454C17C0343CBBD8EB6D8EFB6279339C35BC35F30674E1C8AE202118FCA5D5018DAEECBB27B8F1CE6D335D8E7B21F91AE26F72982A1ADABAC6496E65D3496C789C275F40042113F1B7599B67B387FEF6BE574BA0E50C276809892F36ED0075D6E1544B8377DBE89E7CBE7671B84119AF02F3A636A939ED1881A09A4F824F756984E67A138B0582CAC68D081C3ABD8F545542256822FFA3698150EFAEAFF3EBDDFC8A77339B7982D857CE1CCD1D54EF86EDBC46B1F37BB9AA2BF131ED91D036BDD918E707CB3621C837DE33F8533C95A9DF6D248456D67B184ED03D894D39DBBB8BAFF13DF0193EB",
"E0060000E847591601723024AD38D46C725DFC83A839167330AEDE6FDB8E13F5AE9CAA5B3D1F15A1FC89937AAB9696DDCA36CF5657923F045017B45E1674D9402B918D27D936F053044937F38F3458C4086ACD8D32C9A396ED38027FC8D65E3311EC0916A9FEC97CB49F7DE4063739F30158BE38ECF2DDC51B31B2C660670D1DE89F63AA16A054340D2999291F138E5EA728D178B4715522EFC8E390FFEBC7394472A5B0036661FB6B8447465A74055662576C24798DD4225A011232DB50D991E0F45B73C110C36BD40E57EF88BF84F3A8C91CE4CBDA18F4C676EEF8C57CF0793A1F5EFD7394636F6FB7C7F19B",
"E0060000E83950035246A8493C22879BB156EC2E9E6C32975A0BD4F9381DE2BC2490721B5E515DC4BA1012EEA642E32260637732033CC8EF104D25D7B447CF5ACBBA76E9501C0F784AA6BAC3DF1124762EF0AB72C5A51130D1A321855D1F7F66E8BD8FDBBF24782F12CA53DB881C823EB22A160A33D0C2D9D4DC1FB120F90902F4F801BA1DCFB321306185E6BB4668AC6C7EF553490AFCD228D981F7AF8CBB3C5F558C84D9BD6B41FB5DD9E2F754AFC3839D8888A6DCB9E6BB91BA5C93474B5199098CC450E194EC18A0DDF19FABC03A79DEEF0B3414AA97561CE4952018466B9F8BE10220EABC48DA548A5F96",
"E0060000E88999CF56945462B2086430AE996B2B6E2FB1BE6BB6E4AA3457BA3B8A462DCCB334F66E8B380BF6B33AAE23526F81ECFDAE214765E4685070FB2ED9AE7541D65FE9A37ECB547119698C0CCADD7589F745A3D36A67263D53619EE78260AA66A5FB92A0A714BD2DC0794EBBFA1B9C8BC20AA5DD2AB2890786B56F1B7D3C6D36E16F31C40BE39C65F8B2CCA281BE3DBA63620A303B2DD305DCD9BEC940918876EBCAE4FCDF061E0E2F8851AD66218371AAF0126CE0F9F8ECD3619D7B725DF3CB638968F09F4ADF8D052CABFB30CDCD63AC0317A0F07E3EDBC83032B9958F573275CCA200EB18E4F6160C",
"E0060000E80FC2A592BA422A909CE5CDC7738009A0C62562301E18E5CADF3A86B7462CB166D40D4BD568A1BC9B07451618856D9119BAB88BE16CCEE5509580E7851CB03EE799F45760292064BDCD348236564135A27A16534AFC652B0206A0C4BBA74E22B33D87076E932F2A997CC300C8AA73DF00BC5FCCD4AAEDEC5141359DD4E02DE7ADFBCBA545CF66A14734A80F27E93C153B4FDB7BF1BCA4853D4C14C288ED9E11BA458B7E63C425EF25D3B1074A92383DCA16642DCEE985D3B7BBA0143CE0066F5A29AE12C970C533D23D629AAE217225BA9A0B37A2D8F2484E9FA01BA3879B35C3E1AE30159A62CD39",
"E0060000E8005BC55EC168126D72E0C0413BBA6A21C030271221A38F398C25419DAD47DB129D68B644EC17167EBF6DFDD2383ABF2869E00CF8847A8A94AB539D8EEC59C2D41686C1BA4C498D23DA556239EE29362089C73C831EDA1E9ADC1F82E9B03DD8C79418A26980FDA4BB4D57B90A20319776E39F9A0D401DA4DD3F7E9F5B316AFBD9729DDF64AFDA8AB2BE8D748D41BEE7BEB27149A015CE43B80B9AF53ADA112870F1ACABD7A96BA99DC099808DBF3CDA194FEE8765A0097AE3C08422ADAC22BDB7AA07AD25216AF3768A89920753F479C6B6AB412F2118CA937E9191F9FA30FA3F0BEBF83BF7D9788B",
"E0060000E8DA13C83783B1A80F48935A371AABC9AE45B593FC64392879FD2BB6D4B95D83528FF434514D523DDD1C01D59DF32CFE805231229B985635EC11F4A07D2D52E571C3BADC9446B55BBC90245080AB14E821ACC943D68276EDAC9C0972525506A316544EF9547EAEF302D31E2B6D964CE51DCA3DFC0AD6B65F3453C584DCDA936E26DE4F626F3FF4268BE341ECB2D4E4C671E00852E2DC247085B570626DFB361DA7F5C991F0FFBAF9CB0298146EB163EAA5B636B5C1F066883737876DAB4E8CDE5D52690976243E1B4A130AC4331F548A49D6FE0B39F2E7ADC59B8284DF35710F1FA4C96F2F9165A758",
"E0060000E81B3FC4BC4B67AF21EC6E5BADD4FE038602EB38D288ADC0A1F84EAB5129C63A99E46742FE46A15049A9EDD73A514C5F9458A1C2E62F570CB8F098796BD52158E37917508182D31BEE358897265A49FB958CA613AABA396596A86ADBC184CA86B08B33A1901F3BA0DA9509BBB46E66760A4C8FE4131EFD2F2CEF7B6F58722CCA1ACC8A897C379CAD4569E5180FF1227039E7F10D9A0303EAFC6376ED7AC6C5CA6B4A668D877B0FE1019CB4ABEAD92D4BDD7B01B2BA6D4965A70D934C67BDB0AEF5EDD62AE44E4111CB02100A64E957DF06971D075CBB603EBDD6BBAC19151387B97DDDA2065F41FF47",
"E0060000E8FBA8400F734A3317948F2F3E20FCF3CFA7D2C6E71C5D8D821F0E921CBC481DDC02DB919B84DCE38073412C3084C92083D8F55E3649A6637BE00297693CFC6DD8B096B6B735E457F0E29DEBA529CEE03C49825DA631F556211240783D53A5602ADAFBB2A60B82190190CBE8E2483E116FB36D260848D9CDF2C71F305E435DB1A771D4755766788215B45ACA32065A48654EAEC4D7EA3FD31CC8C42A9F0721F6955F7BED658F2FEE41630AF41F6F32749F63A26917DD799AF4CAFB10F2811A68BA3FE77ACDB31AA59D0079082B03EFEF66BB7C1746C5997ADF902775F26B1FDED26A4D509A1CF7AD2A",
"E0060000E8C092BEE77C70FEB2FB22B77FDA68434197AE7D28ED526249B9AA1B7EB2872D3692293EBF46F4E2A3F6797FFE8F54226E6D67B4F96851859B6660B9756E98CA580E91373125CFAB096423C4FE99BFB9DF72E3C96DF4EF9A5176D86F9710521A5C5B5803D09076A853C252161EE3204D6D0E6A949FEF12467449865E9260ED1DE4A094763BAED5E8887DC9D83F8546ADCF6ADFA889A190DDFD46898046A8E08DDC06738AC76B8AF5610BAA0494337D741DD22EDFB0B8D5B750A042FB2D80782B02CC476EC5DB9D7F34F549C0E6B6F4AD08D888071BF19DC191F2049A39328910A1A338B1F0E021C5C4",
"E0060000E8B2CEDF4135BF6F982C5606EF71BBB15138E4A68AFA89C05A4C7BCC4B0D51E899A85DE761A6178D8888CDDF1833F68B0D60DCB50342CE18ED3EE738E670F82139ECA07ACBFDF21AC7B574E16EFF4BBBF580B0F5C74ED384FA6600CF02FD8D0B8E558706E8CAFBB481BAFA6397CA8670A495D8F575748373E8A532D60080DE6201B0FD9AE46170F716473603B0F2C464329E54A682F9A3C71D5B2A0203D992514C6839B0DF305A40B85DAF4A7C1DFD82895732D89BC2D3337439E75DC50A95342CCCBE47237C5419CF60BE7A3856CA8B606E925A6BC8D62485208D89B475206150A8FCAA47DB0E62BE",
"E0060000E8E2CCD42D722C14430AEFB60BACBA6335D08DDF4A47E6700F8C5519B6816DD0BD84B2F6219D06756359E68B08CC9127C9E0233BC5CBDB4F3B00D45B448552FAD0A585F11E2ED2879AEF0AB35CC3DE58ADCB0B190F7402DA08135F5420BFB1F15CBEB4A1EF9BB0A4543260AC2E2875FBC00D04E6E64699298F027260E88EF1FE5E1AF9C4CB2A6FFF9C8A6392B2A64CCF4FCCD957867CA7D2AE1CAF5153D873F1214CAF8FFF8B1290712E49B332F5339B4170CD81D3D6532F6D3CBB25A31C175759C66A73D30C0248A0997EDBD26E4440C184B05079164C126E424781D3B95276D300FE1080F15F959D",
"E0060000E81661084EB7E9B2B36044EAE6ABF483554C80B423557066AC473D34091EC6D1594033F811AF37E500963B8B9158EED2BB627712D09C83EA096F7E7A4F0711740A1D13C2224FF4C13E489BD9792A80D4E26D3AB695A83F9A927F77152026B34ACBD1F9D5AE876EACC6B1C92B313B642F28CB7771BFACD6AC306B555C752AAB81FE05EEDD3E6EDF9D1A834ECC53775AB7B2CB1CAF72C2783A0BB3424717E340EEC7C75AE5003FF4E1F3EE0B3962E2CA531C4AB0ABE2D40D545267953BC62B0039BFA05A84EE07FBD7F378C7379B5C5202479A0F2C156884ED848C0D2C6D7FFF99D051137986D1868F44",
"E0060000584B76E49D74297FED8B433A83352EA945416665D096B6F50C8BC5638DC300CEAF8D1F5FE905287A068F349481FE3C046FD2472B993B064B77C362511413D7E1D89CAA479985A45B5F95CCFCAA13E7A23E1E7A840642318B37",
"E007000000",
"E00800000842AA5328125D494B",
"E005000008E67347944E05F39F",
"E0060000E855D8F80F57D2B0AED8D4BECC0DD745205648402D35E0FB45815EA801549CD1CB55B92721E6A005C03C02A38799C8C46B1909185F198B24724FFF37F2582E9B6DF4378B81A54E52852CE302348D2E352BC53D36F82F415CA7DFB827B3ED0639EC7AB492508C075600D4863434A4D6C70D380D4D335C1193CDE05C50241F04AAA5480F81063022B7AEBF803C033E379AAC4BC7F212E498778A62BA7FF9672AE605173019AC804063E8C6D05A9E122F0718CCC42D31889B95AA1B1B7BB6492B0DF84C38412C7F894A8F3AE15D6632E93A7E1E6813B04315C18D03E7C8A2936C99D91C8346DECDA4D1D0",
"E0060000E85B3233D63A6981EC478A547ED81681B8590538411A1F6AAA91DD05497AB08883F6AC0F1DE39B5B3CC54DFE091A4A4AAFC3CB2382245D26CB23A1EC2397BAEB68B94039CE6C52ED7427367693695C6383C06120B1204A1C8FD39E7C693AA7EA3E46670402BE4332EECF723B859CA6B0855B2B396555EF2B63937D2A68B0236EF5E38546F22B3A991A512640683887D4C20214BF82E3E46F6CACC7ADB08E29FABB690FF34BB8317109968B351ACA83CB74F5DEB3005AD4CA87A8195C38F065E5C56D992F5ADEE05E18DC04E7C4CC1C49C03CDADDE88DC68CE817FEA6DA4859EB4A30AB840E781D4951",
"E0060000E8D32F75A0B2D25D5A12191CC68768604EA4802CFD3F2B7A88BDC8159A5E5317B7169B6DC8D55ACEAAB76D44944D970CF6E4B361E498404B7BBEC221F610740DE9126FE1CAEE72CD6B95723408C958FB426C14B38C82F279C7F99188A077B6F0EBD0C2826914E4D4ACC388CFD1581126F5ACCAAD896A37218CBA0C5D759B9F06E69542206CD818234881C9EC4ADC1016B612C38821ACF98A70377E28BF12B4664BFD335B394133234839FE31C465981E2AF667B09B412E2FBA5CB380117E86FDCCEB4470830654D8E547A0E6895F08D5C673BDC11A913000496F430D85FE42A481E9F1E1E70F6D1857",
"E0060000E85B82E394AD114E09A5FC8E4BC6AF6D571628A7406A9220618A819962B8A932BEDC8FB3FBFB84D28B5F0DC41E2A85BEA8714FB24242EE1616F9E6F12F94D4C688393ED7C21F69F764B605FABBF073CB8DEEDA97C804A345028D44DD0776167A0755230DFF4711DC863A4C3938FCB76BB516CACEE468E19E948A94D9A117BD01D4FE8F6BF60520386E68FA3D8B4B1B2C58994E4E01ADCB6D8C0E30CFD38B3D20B732BC19E08940B316E68EB28246B188CC4FECD5996679ED093C2BA9461211C585F13DF5F63C9ECA448F265B2DAB8BD4921ED43CF44E8FB9A10E4AAA37DB06614EEC03A1FED2CA1D9D",
"E0060000E8E72FC9614112229ECCCB13D8BFE5070EFDCF37B55D0166FBFF0DFF3615641521544E41BE77B4B9B8E9CB8588FD2AA075611E039D36E1C0379EFACBBCA9035BBF17E74DC81C7B59B3AA5C48114C35496E65C43A78B9F447628ECCD9EB43B108BD53195E3A9093333AECC2F93A2CFB6B952D93405E3F29B3CC04351E7E625EED7BE5AEAC1B0EAF5F3B86DCC2F8E9FD942F30739DA3090AB6249907EE59E42EC0135E6C940739CFC17390471F0295E140CC04F38C81E119BE3EB769D4C47882D18DEC59AC3FCC110EAD88D7944079B98312BB8E8C78C673829BE47236BF91FB62C85328F3802390B156",
"E0060000E88F75CB7DA8058842CF08E482DD37A2A76AB3CCB664FB75492A27750D7C870B461BA2B074F84E17573DEE12A0C759DE96F1B495CEC6E3F8133A7C15826B038EDAC278B8A3747EE88E391637908745DB0C9236F000DF74F8ADECF849D246DBCFEA4DEA64CD5E34A6E32A439813C198D7FA82D48A813203D7523AC136C9E17D039FF1E87DAC52BAF500E28AAC68B5CE9F886B6FC9C34D998DA053DB4E24D74E5CE5F4619A1E4A469C4FE36A749068C562170380BFF8B138600F30BBD9C450BA055370AE8736F0D3DBFE13D462A28F551848FCB0C861435AD669A1583078152825709AF49D1B626B0685",
"E0060000E8034DC1E4C3AD686A7B60CC5977041F3147901CD0779032FF7F43D1BBE27C075075FD5D763D91FB49B83DBD5BD8B409E5D361053A6B270A804E69DB8C1084914F5A84E671F82461EE17CFE30E021CC77FCD077267C9D874691090B0ABA4C24EDB46763972B8F82B94A55D9BEAAF0C9F53DCC5A7F0733F44BC7C50F83FD57543FDF00497B45AF1D3C492BC0EA86F80A234B3AD8B0D0080B15EC2B0ED23916B45571217CF471F774F27C4401C41669D6297063B0CF3266ABC55784C34C0D6031A39C3DF0A5D6C0F6AD966B98975CEF57D332E4C4C00033E2EE9C4B9E2D1CC5581B5C3A2148771A8E02F",
"E0060000E8995F674DFC110D2050CAE2CBF61B3231544CB5D83880FD32A92F824464B562C6A9D9BE106FF8FA506F6BCCDE53AD6DE19CC328B322662895E189FAAA2DE2EDFFCEAC60CC8A7798B2E7B48DE2AB5A862FEC90DB3511555ADB6DE08B8819D73210BEE19AD69709DBF7B97998D2B899AFF6A7CE3EAAB78A5F231B7D69C3F1844DC5C95843FF764D78CC302A9737FA15D3DE504ABCB59AD4B89BD1EEC6BE0FEAE4CF9FB670A2412EF972978CB88282A936BF4B458D4056070C88B693E5591E4659B78E7F64B0ECFC8549959CE6BDB67D16AAC334C88CD248EA981B4DD88DC51A37E70139D51AC4F1541A",
"E0060000E800C86F4D1029959887BB125D82EBF876A5C186A22A6EAF5515614B6DF74131056139B800E3D5CF84F18EC9BC32D7FA86FE4C85B5C5857E812ACBB9253D1C435F341D1D3CFB76EEA92B6F15CB43C700E4481A98B85850AACB3AB0FC9739897A8BEF2631C35E0D8ABAB0524A43210DF14BF48568BD46670873DC4111F0153F8A8A09D3BC8F4657B5281D105537373329D8C9115ADFA98CC5C951EA1E18790239952A522B71FA47DD74EE2DED4D1298DAA8130C4D0A06EA8DEFDF73E1122BFA235D1A6C5ECC677C1B705E8FFB4C2439A7A9DB12E6B66A618146100AD369F62A6408DB57E37E02E8EA0F",
"E0060000E8D7DEAF210D348DE479B92624B18BE9C74CB7B279BDBAD2DDC999D976D23860CF06C4883326E56DC6699120952730E26ED8BC79E204DF6199983913AB897BDC69592F65D2A9479F68FEE58F002AE982DBCDE64A49DD41BD85D790D13C1E27330924BD610E225EF3B20187B485C816D64D98FB11185CCA57C9BA9EB4992F581F5BCAC839384A0318417D410937ADAB792896F5B10D12A5221378C3850D4D9A8CA4DFC29C11B7C4E62A99C54E138668FA48B55100C0DDEEEADC3F36859F689D0BB6F0EE1CDA11221F777AD2777936EB0A18CB702DD3E8DA95E855F6E69386F1ADF9657B9B5BFAB4FCB4",
"E0060000E83B99C5208BAA309F0E58C0DEC364DAE1CBBBC3042027D905640F2472E85B974817C2803ED743CA083841F8B468D47871C91D11106AD7B86A8919FCD2D21B02B88C600155B8F270FA3BEC2DD09F1923DAF863E1E188A2319E55C66B5CFA744B54ED5DFB37299820A6A05440B88E1497FA375D017B42442B465EAF6F0EEA1971DB1CCDD2190A8FACB3A05EEC060C09BE301897DA378C30219CC887A05AD15EB98D6D9C9AED32E1A27DA38F6C3F7FDF76A1BF41977EBB89DFD4A7C62234D8A0854EA33B4FFCC56071D10FC41533558382596890FAF0C2BF395089ADB43CBF5F2B3D1A238D43A92D25A3",
"E0060000E882A7B3A01562D2B7940ED215D1D810AC8E7EC27F3A028C229E389096D85F5B3A576C80876D3CE74A3B7D115D9146C8BF3AF4A8A572372D7D915A7B257E897CCFA11EB1B0A7F69F595ACC4535D237F2C93F1AE3B1A30E4B84967815B5802BE5ACDD2D96E3C601506568CD29FA0813192D50639A3579A684D1B2C81C840847628B1F89316063BBEE31DBEF411B5E727DEFE7F73150F69F4759CE1AC93FA8043123D0EF24D63964DD55150051CED27B7303297863814136D9CD780520CA4D7B563CEDDC6BFEE6F2881BEDD6BA700EE9247B92A24C12055A1079A1EFA7D26B81632043111C4F10107157",
"E0060000E881030D0615EBE9C515601C392F8882387E39AD9802120F91B4357335F6C31F76FD80C075B0C70BBCBAC5D1332B05661D9AA764203C7E1DA05E60ABFD2A8D0BB4236956788A5654E59602B5ED2DE21AD348846853093815CA0951BF71B95CD48D61EE03EB235D8EFD176BD508374BAD1E0BD108B3E82994BC95F54DD3FA934AFB09C319D6C387A6428605207745734DA669C002F7CA6FBEB1395C50CF1887067836A3AAF47088DFA994F7FC671A62414F373803455F6CDB58EF75D009CF81179972446DD30DD22B4A4E19D1AA7AB462376BC705BAC299C18D4EF7844766C53CCE70593BEDEA7416EB",
"E0060000E807CBE6D05399374B8E95936ECE034B1A69210177F3B1BFD493876ACBEF057348B56D5AF399D4FD1819E0AFFF6C16179FCCFF9266AC5E15426FF3811F0966FF5BEC1B6B8A1823CD47DF0C2C7DB8505555D2DFFECAF5E59566AAEE2F08159D2156E0EAD3C59E0A813FED4502E2CEFCD780547720A42D9B68940045939EC97654900A8706FE4F229EED707C3685E2C30F53C8D329B65B445D41C850B45B512D6886745D2B9F59F5B236FFEE230C077D2299594922DFF96C9A4BDF7714917B4E8AB4987C5291801E48FF1AE816D379433B2A762EA52231C12432CE106E1EC947277ABEC05993173C89F0",
"E0060000E87C4E85B0159FFD696504CD4AC68BBCDBC1E551A4896502E618100D45CFA28370187CA08AB8DF309F8F31E151E17D475708578EC8EFB1F7AB065C404ACA2A6CD7DF97203086F65152605833EEB3DE480AAC06B518A23A18B1F6D5132D09EAAE892094DCD29129904B194952B7BF3C33C064BFC04D5278C973E2F45C54473D9640CC30E0B990372DE7D39B193391F8A2D4BECE329A2570EC61A46C2FAD0109024E3F7A8BCE7AB96FE8294B11CC3F329CD7347939143949C00ED43573855796BD4CE917478D731A886D843F4A62C4399B099F13D8EC39AC0AAE28B195EC7306E2AA51C741484DA1B048",
"E0060000E86B441B259680A1F279816A34A89A359DBD9C05129D39EE80E923A1494577C1D74983B2B301673A0A696A059B0D038EDE717A53371B8981784A6299A7ABE4A1D34DE6520AF86C46C39B18E5EDAA04CE10F179234FF9E2B8A58B3C2E8FAD87E6FA0B9B69AA4FC4501D6FD49710615990049365359772C92CA7E8CD8969DD5BCC3F84C615D4A72BBA8A9BC1A61B6CD2C547B09B4AFF3A04F7C2166DD631C795ECB1B41CD1EF06B4EC8CE2CB4364BA3000B550687B6CC20C3683120BA6336208E864A6524152D79CB61399158F3146665117DA69A5200299AD96E1AC7CBC5DE0A5F456A2A2A68433F074",
"E0060000E816323FA52AD70FCAD7B3DAAF53C618C3D6E3E78A2CB62469FCFC62651CF218258BEA2AFC5C2A181BEA46FA0C755DBB56E274207B492FCBB0E66046619563E182A9A303DDFA4C348DF4C5ED731542E2910D5AF4DC61337E9832CD797181E0D08C81E12EA6AACBDC427301AD9E47E70882B63445AADBB4986720F42FB28C40BEADF55084AD4CD275A76A97F7B7607A0F11D83E9CA57E9B70BF5165A8AB056F90273D894DF725B74D60B10DD39844059AE8ECC04D1962D0C67B2B83A092097C71F01738653730BAD178CD12B27D1A3F5D82F93458C92B709286BD96A9D2C43C0D57E71F810AFF9C3442",
"E0060000E8766AF37486B88FBB24E246B389A0A5F36F9F6652B609EE362C2A34CE0C8C247FE01D8A52404CFD24E3D5FA7511E3A3FF70F6D015429DBCF963E759DCCB0FC4354785E87323362C4E7B2916972F60D2C4D3ADD0A0F450D356B4C7C705B9048BE9B2710618A0991C2D8DE0AF90EB748592283B05D7E298DAD8CB11A100BAB8ACCBC775401EF1B381205870B613B5E60B1E5DF112B8966FCB5A2D9C06EA3FCA7583E2EB99FA51F08C59FCA85BAEA344847E1BFE460BC77227C844A0E786D8A73C55EAA5AA320979A2627FCF28847D93C15EB6A20741D9698C7FB368AC5B31D24E7B8EFA7950B3F9687C",
"E0060000E81A029A3B755D94449E6847C32BEC5E12AEFE3E1D4008524D8CBC338DCB43EA27D834EFBD1E3D89F31035DB007DC5106ED29D9D6DF841A341AEA3173D60DC45571C184323B5A1AFF3E85AB931D618B3B64D4538141964626E5BD81D19726C64A4D8FD3E7AEA85EB7F2B62F786C119E5135F0F4A91435DA50ECABA8D1535D36B18C4E6B867B56222CB38E384D1DE7ABD3AC6DDC79DF75CD158EB4D108313F5EB834F1A1AE7BFA64DD29ABDD46D4CA62FBF0E71BCE5769F2C4B49B34E543FE3C14108CACF2E482E0004AD6B63AA2AF52D5C6B07F08B925134CB001F62BA296901CFEAE1B8F0A1D0A8A3",
"E0060000E8D28BD01484CCB51937746AC9BB75E3FB5B7950EE08A612BC6076585A6E56365465C802DE5E48FF84D084C9C9AFD2ABAB33825A2A7F25BB27ED97E98F6FCB47B2BD3335E5876E0B1DD563EDDABDB9372B7F4C1B227FC0019409A9181FFB0FB8C2FBD534D2DAECF55338FA25A24A00DD1E5D37474F9D267CCBC290DA994976E0A42C2AA588204032460704E63A57975CEBEA7B9EBA1C138B0E5C23F928B08BE00CB2F93FA6B9B195DDD07794C2C1DE7C957F2818BE2B532CDC9B78BB94BE2865C95D348E183B4A7B3077F447F02D8B1D0B81DB6CD067BFBB41B1B637D3AF83843504A8A5FD70ED5609",
"E0060000E843D3DE77739A0A81A6B5F2E5C1F12D57772F1DB0042E9C6D2EF04B71DAB9CB2CFA8EFBB0652ECA61EBFB75A793768F2BE2B8023C09984C59F14C91BA484F9640C6BF90A5F27FA3FC10B9A34151862001AE0BFB264BD3396A4544203C325E4AF3706888A3683FF208DD18A5E656A221B7BCA30DF57C3DB83708CA1D3C7198161DD0EB01A82EF556F392FE0F91CA144836CAE212F7D33034272E24072D4C83A642FEA3ECA90A122F8C185A0718B256AE1939EE6221E0ABF2C09D9CB477CB1F2547074F98C1D005D947F38C81B2385A3C7583F216B8D7B5D5CF80FF047C7A391EBA8AB71C111A477BBF",
"E0060000E8059CBA424F2554E3638DD4603866054125FD52FEA34FED972049C374A7C4C0FBD240196293EE77717CDBFD409CB5827B801233B1DA2DEA8FD8BFAC561EB003E13D66567DBD487C0BCC165C2B0854857C247EACC530CD966A6A8D1A67CBDCB4679CA0CB201C33737E4E888D245F598FD96AD66DBB9C6D06DDD588457003E1BB5355F74E7763EC4068A4728A9B6922F0C0B1D8ECE6FDEBBD118F644725DA17D85E7A4EB90E97E34D0FA7050AE38B662C8B88D69DAAB5B19C21D28388E6538E8D0319CA02E8C91D02A26529B8D33E77EBD36440FFEA089FDCA757B3EB63D04AC01CC618244366AC4DD0",
"E0060000E8D716C754CECF96A5E9E081497FE44C830F043125352D3DE232EBC4A469E569F521EE3B34E4364D806BD9B5BBA5DB37FE8959C910565FD19046CF76E5069EF3E33A35BDF4AC1CC1B4314762DC9A76B7596CB5BC9CAC6144B8FEC81538161E81C9D0B12DD5725EF3333249D552AD6058B897A14AAB20341C14002913D202AEFABE064D0AF301EB2485D707CC55528D1C0A7605999172025AA11887C59E28BEB439EA6E0ACE17BDA85278F78AF603C2ACB1FE0D9CEBA6DA3247A6676CDAA92CC4222D3837936C70DB94C9BF30C9B9AC135FE169B7AE27F9C608AA03F8FCD5CB6B29C25FD9522C422DDD",
"E0060000E8A661240ACC4061E0D89B9104713C8682A450F48A0F1CE173FE2893C8162896CAAC88C3A6828E08F6B9D317AFAAF565B52D722D54F214814AAD067BCEFCBAAAE076AD4FB58644C9A2CA81A571E0BB803B0539C51CCE0FCE601B280479A77FE0A253F648108F53F5048BD9A1796D7B7AD0ADFA9A0121DD4DB1DE868B5AA943ECAB58B15E2C85F0076C71559AD9B5775B9B624CF597A7BCAEC7CBBA550D8384214BF3191D35827A93548B310952E7F82C5D5AADD9DA1F5591CC7152CFB9F8CCE7B757FF19F97DD00436DC542F39BED573F64E6A1B2D42BC4854917381500E73C6B8F50B4A1D30D80292",
"E0060000E87D077206691707D5056D1CFF1B9DE6BBDCB0C23520E8B6B0E32C9302C1A7B6CA01937FDEEC06181921AB09041B399895A240630BD824F28022ECC53F61E27F4C43D0BCCA3196F4C812141B57AE6C0BDD7AFDC2BA1822042FE80521A76D2A443E8544C85DFE915C7DE18EFCA4344182A9840728F269E4066F3E925C2517BA2C41749835684F3B66642038FA482F8250B2671EF02B9E1F8F5AAEC9A24F50CB0A62EAFEB3BAD514A718289FB93B95D4E8999E174A6D796AFD25EBB875AA7309EA699F99930B9A5079F59F9DFDAF47C5E74E773D79ED3D9E23CB7D7390F75BE6FC60A8816227F82C98E9",
"E0060000E88301C72796E06E7CFA3F7C5A26FF7D59F6CB54F189CE3C7757372B6B12CF1120B0EB3AF0C1037FE9C82C2E83341D7334426704456FF9FFA74D1A15C8717DACA189941904173FDBA406A0A9C45D15D7C0417102532E87B66F453DA47A90C22104D9B7C1620A67FD809B88F673BB0A837A6199D9EF0F68AF8A34619596230D8D16C614D9A5DEC49B7230B5CF51F2611104E70964116B097847312510EE09898BBDD135752151D78B43ABB246A823CF4F6089236A2E697FBE73BC423BA97A50D1C2183C2AA4253C61400D32B251EDF0D605B82E0821CEC72780969D11568BC797398ABBB34672789FB4",
"E0060000E8342F2B41BD2457CFEFC01DAA0FD5413AD03454084CFF0032DC4D708C43677B4A90D3F8F382F3C50C26219FB27E410E4D10C28D8AAC6EFD2EDF44A1CBF267B40201F99CCE68CA7DA1B4AB526FE32BF37B7E8FB464AF9C1A567E8EF3839AA1BC3F002ABBA87BDF2DE8437A6059924CFE9D28AAD467F31BFEB1777143EC8C7E5E34A6E481F670639FD775C511C655343C63033A2377E2EF9DA0D0087A0F8DEC9157E2C4766490368B3C2A80B191974FB05E353205B8DA11ECF1E5644CD6ACEEA7A1D82ED2C55CF01179635D67F21B193513CF5BDBE2FEB2659694445B066EE5C9B8D4BFE00F44C27538",
"E0060000E83B641CE41C2B65A18E354C5E018676C2FB828120906F2E7F91067A45EA39C1414E2585B31E4836F2E95835E465012DCDD33452535D49B0AC7D91AA29A2143CFA308230D4B7104592E7643B62F40C2A743F509326784588AB8100930CDE629CD29630EA9C1BF945A51B7BC100ADAA3D7523C62AE435FC2DDF33364C04B884423CA58C1CAA95AAABFC031058E4B8EFF16C5B3DC1BA09095076C27C3E8C8C3965C3B2A543384F7CD7915456A1ED57DBC2157E1BD09DBAD25FFD2B2C20F3CDFDFEB5EED99EF0281F7DD0E25183B8B357D9DADCDEEF3794C5129D556BE6EB76E4225E18B2A047F3B16545",
"E0060000E8D9A8F15D236B79EC7912C2EAC9F5945EFE4F517A772010B99AA80BAF0824B7D8926D1B90DFD6A72A66F878191A37B6668713E5715B19EFE735DF4B24286C5F46E6A6C949A43E1C6BE1DC3505117ECEC930C170F9A8F35D9E2F0B89A92F411B39686F185C96F984DA0136F21739E6B7766330AFF435CCD70F3A5C0595E96F515928C489822661F9DDE26E34906119E3C70F38DE94CCC3D3A46F9AE515FC5FF0F09661D9AE9B8908E5E09EB66FADA8FD481C842DDF68139741F834A7E24D440CB8D3A70F02FD17CACB6EA797FF46198768355F57CC8CE616BC553E5B60309216E1E473A6B308EF6067",
"E0060000E8E0053CEEC80F1FFB92EE9EC9BAE576AEB033D6DDE3953C4A6D8DB55AB39FF519531A36F161B7D56BA48E4309A2683E5928EF3CE3AB477E4742044B625C0744D6A9710E50850E07E7745898B4BFD737406B2820CBE587FE4EE993C5C4D0F91EEEBB7D5B68269E67BEFC53194C6C6F38ED3D1C49CA8495FE21BB09858A80EC219259DA662DC0629EE96EC9EFCC47979378EB18FD7DF315C645929E4A836FEF78BC6722F8FD63C47D34F7D315C353C9F335A3FB72005DA0BBF1234C9B24AAD108D67681F3F9382066056AB305BF92835FD8F0650D0742FD64C9B1CED4719ED4C7007116DF8B981C1E56",
"E0060000E8D6B3C6873598EB200E23F59F44B6C0640EA6A342A3ADCB49F4A41322656373648CFD1DB4BBE83CF6A8271FA17DCD574F47F6373FFF423A9D11FC4A8AFB3F707CFF0EFE742825433D0A1DD6C19A4DAC806409FED12588FF54FE1B1B6DB64632F21B15F014213AA00242F7AC0AA1C3CB9AA61CFE108322ACA0617F5BB4E5DA084441609EAFF6618F3CA89C23B1C917A5E5C3021997170B693C0B55B71A4CCF2547E7EB5E844D34D1D65051B838B1F6D5B9BF49A3A9AACD6A0E59A05234723363D5424DDFEEE936EE1EE2217CCC03D3842389EB95CCA8C6E283F8024A2B11594C0E44FC22E9DDF871FA",
"E0060000E86CBDAACC82BD2315B67EF3EB8866AAB2626892AF469FC25475E4813F55707034B58EF6DB65BBD53BEF68925326829BB988B2F704032933C2B9BA8F8B7A96369CEA271F456BBCF0FBC655FE9064BB9DF5DECAD6E02AD32D6981DA1B8B27722A2E3220C7EADFE8BCD49FFF3EE501CA5172C050A1329A9962A844AA024B5752C7D0FD25EFC94AD2187AE51A797B8FDB331C51A748A53262EE2EA3D32FD1E1C00C2A6ACAA22AE78D49CE8896689FB89CE9271F56BE30595549A0D1EF19B544DFC4BFD814BB6DEE4219F5DAC7DDD006FB8F886C49FE7562E924DE9AB7A074F55ED43DB354169D0373DD8F",
"E0060000E815AB6C92F20325A1A7C8730EC5A6A0A5E00B8345C8893D51DEFD30CBD46085F0F4D985F39C476477382642546296828A767F88BF77F73CDDB2CD57A8EED5741708061C45F159C997284BB8F6A56D11A729482B015EBF49AF3B80CCF324FF1482D292464CE47DB980DFB8CD270E0719EFA1767604F5D14BC0F7DF7A453136D0FD18AF442F264A4035B7FEA7A8A0B4999145FB53D83BE44B770CE60C9654277CD435D03ABAD7C1C2158F2EB5A719E1E599B72EF75243CC3F03EA9ED9A59BD3FF4D3A594B157063DA3DDEA0C86C6C5024810CD417624632892BAEF8BB6E899397DF4D75637BF5092EEB",
"E0060000E891F8BE85CB13CF76D344E813AD086AE72C3BF4BC2A27E7CA409107360B9A8E2C76DC41B7B221F17DDF75940BC73BF7BDB95F9BAA79A5907257932E391700758FF831FD00CD22AF8F9D1E5295143B9C37D6AE2E1A67A9FE328AEE19E12C0C6F87265CCF5A4DA6DC9428575D4413BF9F823195C6A4BE16585C5CAA1D7EFE83930564688781A4217E7C58B9C13C950590CA1475931B08357CA07AAE8B761462B6BE3DDDA158039BC446624261FB59472F50A7234F7D715D17EC2B4DB732F124D74F55DF74C45C622B58B35A4CD31FDCD4EEB9D97F76ABF2602FB2CA548060B9920C767FB55713A892F7",
"E0060000E8493961AEC629587C1571A542FA2ABD39D3E90AF196AE3EC8E231952857247465BDBBD9705255014E1E6C7314899C2B29AA8BCCCBC3507AF7574070EA67A1F64A5E892053A6454653CF81E162E39D70D42D41357AE16747336EBBAFB6EB3FBBCA881B6982F19AF27D7282457DA35949E916B0E14FCAFA81112A748CB3A130F8AACB8B35A9FE266FD0B774C097B5FFB7ED7471D6E443D8F821C4075CD7D9A545EC18838C807E129DF371C4A77D07D2C4CFF0E4D858C39FB11CA14FEBD379623B5CB05B2121A4FD3A7ED3218079F37491BCB684FD7F75208D76155419CCA1F648204B6465C3A51C2530",
"E0060000E807763EEDB1CD82E16E8616EEBC63616A6E7D46951D7965E6E83CB58033DA86CAA0E231201A47A67B07FC09D744E9A87E363CF957C86A11B1556A7734634B662CBD53AEDB02418B346F42A66907712D7EAB51D1EBDC732AFF90BE4DA9C863A20223BCCA0EA6BC09218A084792BF679301220CEB8938177B4C08E5707AA8D0F0896FC96B5190ECB15ED382309DB103A68A4878C6051CA63C13BDC39DC61F50CBEFC10FB983D502E2480E99AC9D2CFCA0B19CA30F6D083BDB0F22E2450D51E284D7B60A81020C3E6BE0D9FC438885B0025992FBD5F7AFD111687E27064FB29A019286F667F6A9082357",
"E0060000E89D97FE107ECF0CC1B87A5FF75F17A48A27A8FA02DE54D7488CCA7617B535CC53011709551F54827EE8E23093D2A6D5D5F42C4157694059EBCFA66E2A8ECB096182F9B735B5BFB35F3C4E978DA6BF33FF5A8B673FFB1012307273F838E3084406E3E2DB3A217D631B893F181EE30047E7DE86B9BAA7AD9859A1AC0A33BB9660513D9A02670AC6724558174714E34E97B76DCAEC709B117F3CB7EB4EFCF120C629295FDD0111C220F7E81DA0E51CC05073CCBA38A034DA7A8D60B9E0E2E2A108EC781DEB4341655305F3564A7256CDE2C8B69EF5DD45DEE7AD5E41384ED938E9994F97581469C9348A",
"E0060000E89D4C513BC7B0C8CC619201A1632386B2536A1559B27A9DCEAAA20C101E316A9BA41147D7F0869C50D3AE3BEB5CD706A32EE89DDB83EC99193C08E6BEB34295CB9C3BD88693F9AA076FC80E1D0BAD634A49F0DB09F062C97F5707296563939692E5703CCF7299942295CE20ED474F17DB4412EA0CF8B056053839F179C90631246955A81D5BB5901B104D77439D0DE4F9DDA44291B4C9AA0EB77082F8D3886328D3D7F9516A86997D662F113B70446919EBBD92DF71D12877AD361596BF83154CE98CD6DB826433778C4CD9B146CE53406C2A699BD36EE2A13A6DC395F973D97081FD7D2B956C1EFB",
"E0060000E883B8A164737E3C83015F5C60636807C0E45BFF988B3E89694D73EEEFDA91BD415A1AE247E7217D6B2591029BA227BBDAE6E67FDC5507DDAEC640F177B5A05A4A6069AB277253AA0BF96E3E3D6C898377E2BEA6ACC6E54A0004F5B4EC2E95E4B14E5765C2F6B087858A66F1089FFCBCE2E609E807C8A47227447B06DA7B8F0F819DEA1CBAC190254F63C762929E5C1FF0773C62ECF0E9D7B55E8903D494F278FC1197D968541BEFEBB8940D86409D9A0B9BC80540DF59A653363E96117E9ADCD36ACE82262B7744DAD5545198EFBB5E8AAD711D472E689B8B4023F98C8EDED354229994F52441F8AD",
"E0060000E8A7AA0A0F903365AC49E3910E1F7E3BFE313347C65113B0C36A01E7ABEDC36E46A5E510865742E148C3A47CC6A6A47CC3F50D30132EDF87455CEE2A5B55668F9C9235F3C31757CB7FC6539FFB2E15DF81951AC0723340546F8A04EB82188775A37D9A60D2A4AA12179978CEA5D7AAA9581D4E70C91360F51EEC25FA0639B3DBB03E279E8709C48CC70F7E1307FDC545709717B882874EDB8B2F9D2B9B2F48F45A6A61CE4BE200C07BADC7F397A8A6938633BF6F7D1F12A4CDC4B697C3F045D692FD327C1DA4F00F788FE22382FE7E7A79F4FB3DEFC2FE759C454ACAA2F5D46A874875CDE25AB99C07",
"E0060000E84C746E36942FE971A1E0F4464DD251D184C5D98549735CEFC4B4645785D7DEA86526481993D5CE2E7BDC9A593AFCD97F618F780D41CD04F5790A96F23BC27E35C5E03F2F01D985AA68A730D920F80B69A608C4C97CEE599107F65006CCA58FABB0F1DB9C63AA270270D352A1FC55BF91E9E22CF266112BF1C2BB5F512786F7F38C56F1AB538D996B22C33A3D854E1EF421CB09AD475C18100419AF661AF32A80BEB27D348885960E178C9EEEEB849C138FCF8834FCFD8DC9AA9173AAC159CD61BFD8604A9BC5FD4FDB828B7E189E83D83AF9ABD7440F9728C1EF39A1D8C5AF78E23C5FF2E68D4076",
"E0060000E833CE83063FE856C99F82A05E2AFACC71AC61D03A0CFC1C3FEB596D96205010316D3440E73DD4519466750AFCBE694DF016FCA088034B8600AA6AB914CB9FE098A82653326A0485E26113C97D6AC8A39B6DE10D33A7699B4DFD3724487F19A3E9DA79F36E6EDC9C2C5789132B34F7962E8F6B6BCF1DF9EDD177F997BFD503EC7004A33EB380D5AF05F42B36F88B950231F0EC6277F63C50DDE00EA28BA39EE6EBA0025DE51EC8F266AF5087F8BDB60E3356234C6E185FF086B0A9C5BA8819D5F1149BA28A3BF3D8DE1B4E98F2D3EDD2F667CE3D921FA3187E26F303A5B4DB5B8D966A72CCD189A229",
"E0060000E8BCAB63EBD52599D8786673110A259336D6F96CFBB4F3E6E195850AC4503C2C37A4DAC0C22F0649CF306D51FD7B5CB03917EF67B184BD50E52D78C31F774C0C60C20526F55A7EBE337C6A09FB4B6A173B19033E4C9E724A204933C25ABB4FABD7268F8B2CEBDAE8C61FBE12C9E6321397606B57E9F87D9243AC35265F7F847D9BED1E0D9856BC699A0AA0845E29104BCECED1892C8622D76CAB77D20E63753F3BCE2AA3180A377956123B1861F356119589CA6383BE8B756B69554625B38BCC74010BC121ABFDEFE9510801B912471C2DCA6967D353754D3FF3BE58D97F959277771440532B65739E",
"E0060000E8DA560F834EFE618FB1AB037B279F6DB7D4B62F11FA1B6E77F9E2508A2AB9BD747788F541C2FFA9B23F5A73BB9AFA690990557F524F672AA290AFF97862B8F582F9D5620905098EA3F2F388B818898EB31D6FADB51CB3A886426990F4360D8A080EB5B44C055595B03AE6C076B6AAA1AA942D0F05341B5456869483288759F9B0313F6C0D0C14DFBC6A6C6EF34E0F5B3726653D908B005BDB8DCB6F42EF6D550C1A336C06649F41C06321A45E16504567B5402A98120085FEF7E33F48ECF7CE93887317D3CD0B026C2A9252269D0A967E5E4C7DA1A2E7765A2F00DAFEF980E6DD56E2614D3A53F539",
"E0060000E873EF9E4F7340BDC44D9E03583F83473B5BBE46B09F7C78F81684DF6CB79E7E1843518D9AFFDD2F18EB1DAD4A0DF282509E10017F89A5ADB1CD8E699D6CA3D7CDDBF8E40569E510E80C4E97CEA1EFF3ECEFA20D49214B9B95E2BA031E00961CC5D82178F073CDFF4A361CA3894AAE815E85EF51763B7071EF5306E90F78ADA2EE9BAC6CA1F8B57EFD1F3BF7D552465EEE37A4C040EC9B183DEE8C9E14E8DD1557D8E006EC7281DADA8ED774F3E03AAE83C3F8968B306E9943AAF313D19AC8A12405215D6BD1591E7F1EA9A50C044F07E9470136846174F2C07E963B5545D17CEAEFC7D80BC8574705",
"E0060000E800EC75EEFF738C7F52089DF664604B28B53B51D33BED497CD4B52686B483219B58A58B9F96BE3B397AD3D4FBAAC42F9E9E721D8A182BA4341D41AB22AADA95F56F5BC715B17064D1EF0444584FFD148C88031C9AECE2603763CD689C2CD314DAB762ED3FA4EE4E9D447E54292FEBA898D590B0607432C82672215E7991CA9F32CE3AB8CE50E25D669CC2A0B43985048F94B6A50816FBF8171D6287AC09752A72F1DE35BCE605B66304D0F6E6BDE7C032531C7B757DCC3252918AB04175F0D50EAD3FE5E6F02280774E35F9151761BA708290F886B70B6DFF46B6B062555A3EC8964423798EEBCEB6",
"E0060000E8873BA8A3F0FE191851AB3D9B47EE63D2211C24FA12C58C9456C9ACD16C0601262F2179A5319D4E540F342DB0A5045C8658ADEA03D40C5D68485F28C16530BB78891F8FAC69F6D3097815BA64B79451664704C560AA456D94775928FAB894CECFEA2A3686830C1CDB7555B0157E811AD387D4228C5B64A7B58574C005F8C57B1A3CC7858ECA5E6CCCACB4E8B3ABAA1453ACE461C38E834A9B24827576C0320DDE4C1F41AC1CBEF470CA27AD76BE9F1BDCE5497843ACAE5D23144971012CF9771538D3C1FE8F021F0401B9AB0BE5950C961C2DF1E0347F0DA49ADEBDD1ACE42C45219CDB03DF59A4AB",
"E0060000E8773E0C1D14FA64BB70B84E74B77EE3E864FC8A0475ACBFC5D7D4B2BA414B5EDA25132E95213A7AB6BDC371E1F41CF52ECAFA7876BE397EDFB87935A2F1D8606DAF5A86E39D32FB8DC2F8755D6203C9FD86CB8F83780A6040CDDE706798756D08D1A539847EB9F14FBBC763D112568FD7A4EAC01F6A3EF02A6ACD6749337B7D9A48151CA514D5378F61F4617DF26A9DBDB24B6C502DD651F10CC1B0C07CE3B33E752F34201B111B9789006ADE2E632C52F3AACA20F0D80532C4B1161E0BA3B052A020FC6B7C123A1DEF01A37EE69D25111CDC038442277C176C7FF5CA01CB8858D8B3D9631DE5FC28",
"E0060000E81DE54442E8EAD0EA395FA21A360F4A982AC9B41D75BD3352A00A4972A6D047DF24B3D7B4FBDC414B02F459632E36B85B85A959704566E274680D8D14F22E45FA9426D06102AE82697324D7A827EF98F44F77609F482235E6D379203BEB44438FFE62E24CA25D84C0CA91D3B16755603B2B97DA7D6B3D232525AFA4157AAAD9760869F32812E621D7A7F06228EA8CB25FBD105887F7707D378537402FCA13FDD71465FB21ACDD5F1B88451EA782C6B0BA2B7DD0AE58249CE1F8740822FAF944F8E01FD0A89A432AAD1FE258A7758D5A978335C5FB7EE27A2F3CD2ED93D6F056E236C0EED5EC1BE2B8",
"E0060000E8FF8ED68BA70C2AFA3732C26024A16133ABBAD11438C4E88885AB98AF9045AB92ADF54C2E1B2E425E6FEF69C18C77729F50C04D5C54DDA641A96FDCAD3DB003A83F11ECFD012871E1298AF6A5D4B5894A98A2F80903D26DD6E24A54675370C76E378E8D46C9245806540DE8A1AD462E09FB1AC544D09BDAA64D8BC136F984129C7258065D2B09E26B1AF5896ED64C76DD7136F40EFD7A96ABC69BCB66C59A1A2E1FDA69245CF03515D73BB53A6953A483378E6D1F36A07E8CFDF504A703CA458B647FD99CB26893834E98E1799B6C8C53D07DE02DB76FF889F57DB3FB71F5632F094B35CDA720784B",
"E0060000E85D40F4C56D95E29A5BDA1A573386FE6BB3467433D95BBFBD3F6E8F0A201D01C471D6AD90BDF29FBAF3BBC27CEA813BE3D7F2C7F62BD949024EC1A67E6709519C0953AAD600C2B6E46942D20A915381386CEC8A9F267C2E07F8F1BDB5AB2D03153793E467A67FE369BD03FDBDFBB46B172E99E0BE48291E0CFD16D779582FF71609AA732CA4FC05922972CBB19915246083704EF3F9DDCDB2006763CA538959DD225C905F14CAF083C4A8CB902D3FA376406F775D850C31A9735C61A98A6FD2904CCC687BA5330F6A30EA58F35965876A719E7E6E937915727331EFF185A51BDE4E640C4C988C2915",
"E0060000E8E41A0F34D7055DBB11078FE06E4C10FE3F3E4F2338B8B6DCCD5FCD11C3F1A59077BC9496088909F12C3FCAB0CDD445178B5DB3B41AF6C74AEF560D10B72C9806161DC8CCE747F878C6DFEBEF4F426026F1061D56E4628EC7F3D7D9EFD490B36CD99B809C26106D7AFF5AAFF57D7DEAFCF480DC75262B156219E919187B84AB22BFCAE8F0FCEBF8B7374F842C9C3C98AEEA6913A25E61F1345DA51FD5943578DABE9AA1F27698D3DA87FB0E2FD1D8A2825280268D90801F293CB2C7A8D58EFB0F26AF9FC2E5768C0CEA3EACD7536983CA497541AB42BE539A7A6E35D86DD8441440677A9B04E8C19A",
"E0060000E853449C378BD421EA13DBBD62585ACE63940C76E8C855DD6F85CCA972A531F1299D4561E01F9550B316D1F52D18A485DB626391CD3BBA68383853B6AEE37CAB17C19A606C8D9B4CC171EC0FBFF71331E5FF9D3CAA550475FC53E51EC7443052E9DA99EAF33416A8BFC50C0BA7B661ED4313753CC25D09C19A6256FAA2A76EDD33AED2563DD59A6012770CB384F1AEE4AB3B946FA21FC1A21B5CDE4F394A8532C07B13A288604E5D70921E3CC7E0BF39E70124921B3BC5F8848752CEBC04A9BB9DB2C7E73E84F778CE001FB8C696F2BBB100EB245EB397C7C3496634D382B555A6608E696AC5EC2CB1",
"E0060000E8020FB46EF93F84C13A1F8D5FCC357FEA9010C0AEA8961B4033FC4DF8FB63ECD5C77B829739E2F17B7F9FABEBFEF1214F438B0F0BA4BB40560C9F0C3DE601CB3E6A2FD094564CC755AC54492182B5CB90637D39F237D32F26841B24D0331F1F18F95E8F8EA510148300C01A75FFAF100FADD872BFF571C718D3427AB5862873A5CB9488833364D5EAA4EF43AE7EDF94503F83F37C1CD08374DA36B0EB5109FDED4FAEFECA553CFF6FF6EDB434173A981D43F20BB9C6E9E0293EA2A2B12EDD695A388C00B79E10C9133B7996FD3068F8FC30F5D8E90A1DF6F598B952836B22647465301CB5ABB63552",
"E0060000E8218969314E07DD935A7148F091BAD13CEEC5905CE96A931081C27F20A989528739D7CFBD27566B204915989069AF52366FBA362A0EA897CDE765465C9FC945DB518FEA8808968125BDFC711EB560E7DD0225E9608F6C9B5B0F292720CCA32E066918103D3AED908D31F41164628586979B21CEC937AB1BC2A212481BAD25F40B45D80B1A57A2F07AB85B215354857191D13F261514919660AB72787A21AB1D5F7CA7D577EC181D5B3811102653A91F80E247E1961F3EC69A48D7FFA1A31485ACA6B3FACA20571A88A2D6E5FA860768EE83AE2ADAB11A8DCE216C941EBDA61C5012264882D21F23E2",
"E0060000E8227A2CA82E4FF39291C8B54D00211085281A108FF8F7030F8222E1C667C8169A8F4FA5A1E93C384F8532206AF8ED51FDEA69BEE92A40838F89256F6386D2CD1234F447A33E684FCD35642E11F54FAA53CC987EE0836113B55750C951EA8DCD3FD0477CE4B7DAF4C74E3E4C2C2CF6A1076923418EE9A61F620F6874EB155D57C3F3476245F826715280F0E0B790FC1389F4C90BE8658F428912AC90C858EB91C40CE5E5958FE0DE8F2B0CDD1D1E83651394E2CD78DACC1877B953EE94D52666D6403F94DC4857C43516E35802BF1ECF31E15BE4AC04136093B6A6BA01D2746D46C0F2F13321B94A6F",
"E0060000E846326BB052DA10706C869B58B74FDA2C6F855A0EDF799E1432FAE914955E2EFBBCC513B027C693E826BE90857F576D27911E11C9DFF92675BF2E7453B1DEBF102906D18FFFFD8746DA6506E342A6E0B5CBCDDA931E36D2359C8642C1EE8AA97F663BF69A6CDC16EC1C0A31C4AC88C962D4A666011FA27DFB6383A2FD388A3448E05D782AAD4D7E8F056E464B499231004D7AACA068B5E59F1CB3EB80DBC8EC35316B37BBFA4302EB2F9AA99185E2EA537A87EF39311200D41D8244F5613C2C0F9FEEEA6AB366BD9650CE57912FF0DEA1D4B88F5B819938D7AAA828FE1FD479109AE0877A05F32E30",
"E0060000E855926A627AC1D21BD9DE9D6A97F85F8098DBF5DDB31C49610DA696B3851017A10905AFB682B56A3370DF0D9479EE34A7ED873A6A59F8D31E3D6E18EFFD90DA1C36E32BF3C59FA20C848D83C9E4F69B872185DBEA4BEB4B9AA7D85AF2761BEC6DE0DFF1D23C30A296608FD516BCC4DCDB46FF5BC55A6EB8B982A12667BD9B85447DFE998066E66C0E6405BCCBFB419AE3B044A5D81DA7B8DA35D208514E93C7580B2251C94B9F5A25AE8E5C69DD059C2EDBD88A4A7A1A69885AC0712FF94B9704BF28B658DEA5FCA2CFA2B6E2B3D1A8569AB78D9D3371AC2D7A516C6D0058FD16DA6F4133E709DFCF",
"E0060000E8AF29840CF1815CA37355872F4CC09C7FCCF43C13DDB902B8362D0CEFCF153D821636E05421B8FBBDE5499C1C2AD01036CF650B7C6A972424C0A4D88B8EBF911D0C7F6C41A226DC4117FE26156E8C96E77EFF66A7DA1FB292CE4D243D6F7CE9A111D51F199900106462F9252CA88E64F8D3FFDBB66AE4886449D90A7864BD61040DA2DB437B69631E614E3C11E732FD7EE2635BE06796FA0741525EC1D675FF16B776A03ACD7D12299E9559992B6FECE7824FABDE801E74A196FC2B195B9527E4F6D97FB90D3B02CF5FAB6A4559DD6D2292DC75304559D65486FF96BF3C403E549B22CDFA7318652E",
"E0060000E8CF01790351CE3C7C0F1CA3088B581142349E49D980F71329B4F48E416AA59DC3051BD13BE9CD31D555EF838D51873D6D6931D2F06216DD0224A2FB069BC1834BC33043397F2B77BA5704EA38DCF3B0A2E8ECF2D1BAE75504749A7979851A96A7486C3A283050AA3251416A8F3AB0FFD44EE2BBAF74FCE3763D90EF2FF77A220F82A4F81A97BE8255607C434815D4EDB18F6FBDF42E5B67DCABF90B41320C43C68DC3CEFF88093C7829ABA43411155B1B2382065CF3EE0CB8CA486D425930798D922827FD53C5F7E35D5952C1A792AD0B7B8F59A3FC22BA45062C9D08C73986D4C00DE95A95C933C7",
"E0060000E8046D340ADEF1AA6739D69C25CB138C448900751278B22447DD7BE3BCACE0225D3D3FD02667057206A997298DBB5CEEA57D513B851013330D989B9AC39717DC7A502409C600B9F593D35BECE1C7D477833C7115225C1093780FBB3F06A2124D6DA05D7DCDA3D75DCDC4B209652E3FE6BA9242C01F2AC638137A892201543A6A2734D6FA7B70491CF6F2747EDE78836A1765198E47A5675772C57DACE1D46FF0643447586BCC7C24E48D24A404F041A5E1B0953D32EAB155CBAA3D09BD8EE0837A0309E8B87A3891AFC0C176EEDFF0F677C8549AD216D26EBDF830F7B2EB3CE91D81356482C6D45293",
"E0060000E8D5CA9E8589C197D6DF80F61F4BBA8DAD8CC03B875D15EF95DE0EFF59FC56B4397932B0A024707F232854FF7D3E361DD68B0730808F7B7410DAF075D42FD7BAA9B4BB7D649B7EBC2032D319AF6CDE411B4B29222ABF8CF9D5E9A5B729249550A4F9AAE0FC4806E1567C243A5D94C765219C6E6547ABC66ED147C6458949D586E9F683A212E4C8F9BE823B1AF72336AEB28F131AAF81E9ACAB4A1892C9953041D8FBBCC532EE7AB5F6A626C271818D03F26E4476BF39F8555F58F026B42830F956F866209F7E4D8D72D4AC654B2AD633686D9FD68A8FEE394E601D59F909D683E4A6446F4ADA379B2D",
"E0060000E8A4C65733615CE380ED67A8B339165D41E9D4787E5767EC23B9D90B69BD8F332CF776B5ED03E85C0B8CF83C412126E83BDDA0F653DBBE8BC3800DE32D7E7E070F42A63D39A56CEE2D6E1943E014F6791AE985F1D9A94D92EF1B5F7467F792C8D432002068FBAC9FCD21CCA81355A3699CCF0B98A2DC6239BFA188CFA2C8CC3B8BC8A4737D854A62572D6AFAE2C428AA443E3251B268D6FF45F28758FB964E07FAF02D2E2FC4150CF36FC29C0C9E86F9AA123A719D96E30734B65A93AC7C9310910CF6ED09FCA06DA9DCD1675CF439AFAB1EE0B1ECCEA5E40D2E5AD4C2054898206E4BCAACC5EF7D1B",
"E0060000E89EADEB3BB381FC9C1ECC1F7D13FC2684E9D077BA84FDC864C67E64544C64B19B4003EA226AE6E37E17B2283600C8A33F1E14FCF4045BA59BC5FB05187C7D355977E1BD2C26BE9DD57E86AED47E6860136C1AA7057E836448386093FBA16E34B5925B7854DCF05A5072AD62490CFA019CF406C2CC3C1DCF83B057138458475C524AABC9D712151DBAEAB3A7AB4446D5AE5F0EFF0330A21294B926369C8D5CF3BF6826530080A4BEB031179A32086CC27E1FAAC292251ED6B5CBEEE53583E36644504C3D4C1AFCFF1EA3FFE089F4EB01199A56903AF154831C9CBC01DD3D87A97D1C2F347172718D26",
"E0060000E8C4F0312C1582A5575819ADD6DE132AC9EABF854BE757B2FFC07EBC0B2FEB23F97DF6A19BE6A60A073C3E6EA829866ADDD6FBE7D9673AB9237D45249F96E26A83E8B5839EBD1DCE911644A8654940472AC1DA622F3EF2D6A74D3E3021771F7F4DDC6E374AD7339B908D066BF9636270FA72922C297AFDD03FCC677D647CD8F8B60543D1FEF8E004C155B083F1B4B70C7313CEAC977C58AAFE9E3F83BC82A1C914F853D7E5A8948C38706FD2CEAFD23B588AA2A267465539B4D5F28E64A4F4655E83C0912641FE1FA8FC4E8B987D6B61FACC1F6B6AD2A26075EA34E9094E60B6B626F19E5B273E01F3",
"E0060000E8B6E835CF69713CAF19DFABB422CE36B4163343E7304A808C548DECDBADEC6C8F6946BE02049B50DC78B5A5955DB2774D9EB4816B567B8EC87820CEE6D7DCD62B710D5B02D2582546AF34D74E2E6687AD85A36EA24DE3814BAE12E9F5DAFF4018BD960928F394FF6A51BDCE80CBCB47FBC26A0F3D341BB8EF841D75EF12797FCA720CA32B5B81E79C2AC2D1FFABF65AC46C4A13D36EDCC94974D0915B497D73127EF1D0B1290A22AA4CBDD6C420092074F7B641C96964FEDC133E623AC2B0DB64A08ADB3E5B4AC543474C796CAA8A0FD6D282AEE48845B6C4F090E9D9825FCA2483956C1B2E0129D9",
"E0060000E836B62D97AD71E41EBBF3FE332A794BEFFF9C928CB6F0AB098B71B2C4209A2DD14CE37B9E4CED6541DF3AF70DC3A35862F1CE278796B3F55687B966B199A68CC661EBEBDF39721D5431FEAD9BDC6DA6FFD43AE52C0A233CACCB487F2508A9B666A6AB6DA0A444F545E73B5D602980488559773CF89B2A1E95FF3FAD791C8DC0E3D900F02C4126F7397F4D40D55D654EDBD4EF2BA76400434833A3659DDBF15ED82CC5D527F0135E98D26669998DA7CEE3DE4429DF4AE9B4F95EDE7FBC06A1B853E054FCE0D4E12791E3208D55D403B80E3011E75D3E71505B515E8B73FA2750F51CA80CC5CB4E8F2E",
"E0060000E8FD35E82370F9D98118F29FC3EA2984E74502924CFB4A9BE70B153652380E976E6BDFD1AC71A3448CD0CCE3EA041166A16D0F92133A983BD7BE6831DBE0B85BBCF4E0F3B50FAB4159323A7592C3C1B04B8ED1A03B3ECFAA8A97D527C8FA3C873AEB9ED50E066C5B9B32C4C93E8789C31D01FE008D9E39481816AFEC97C94FD219F31CAAB1C2F2ED6051117E75B11C32233A0A5A877DE1158BEA4C05FF040C7BC0ADC5F10D9AAB30DF4B3F32B4D127BC45FE45B709654586F00A68C2E99335D8D76779877B22DA48E0A4EEE93B1091929E34A6F6E1C5960D49278E9533FBD73B2DB3ABC25CB37FD23A",
"E0060000E89C3D2FB13722CA907BEA5297FD871729EF35B489DA393624ECE5EC81956952525C2C2C00B4D2A42814DC8E76F4ED7A7A35F2CEE4ED2C91AAF3F5580361E00C77C79AEB6FF7C487A7DFA6EF4372034834DDFAB4CF478DDE0B2499D1D69B481CE65CD5957DEE924BBEAD992C6971B26E174008F95D850DB22AF9D86F4809D44C82CD3C08551F2EC08314EFEE8D7B9D98CFDF4EEB5940939794F6A6F5125437096C886F7A107B63218AECC3F2FD7655F8FC8F43D921FE1C1ACDE2F84B2606897D4F13B8F8AB7811880BA23A7CFD4C2BF931321308FA215BAA6B3613A5E1ED3C41F994FE82D981AA25D8",
"E0060000E848E45D77C576A0E3DB9BBE86FB0F94C7A531DEFD08EE5BEAC6E3BA44D6364928E455759752122562AE38FC882CB6667A1D8002B0F143AA6DCA6285DFDCE3D33F648DF0FD4C352758E41EE59160C686B6A68E378D69761107D29F5980C4945302677B4DAD4F19CF38965E6E3661641F64E5B0A8AB70BF25754FAC8BE2B235F088E08F53217B06B7CEB4893348ABD1EAE2A9FB59723DCF0664FB8481BA31C57C6E578AC3F0DE912ECE8A26715D38F02CCD9EED637B52FB9D7AC8889CAE9755CEC23B3751DEC3956F337C73FF03DB0845528F39BBD0794F4192230F42E69516BFF7304EF4F4B0EC0B05",
"E0060000E84126B0E098A51A80319FA8594555E2BB7EA817BD77F958DA67E1CF28C6F789E2C57DCA20DF70EB1A703A44E8BF856001AC101F4CBE0B5B22CF89002C107B5DAEBAAB2AFBE9A6B4091A797B5223721AF65FDCE7D57144883D9D2981C3D429D275E5E9BF947A58F7793D08A43184E7C38AFF0FB3974D1564E882CB1A7FD7A3DD08A5E5888FA080B7E0696A2B5EC206AA5F35F15674302158B58950469724048AFB83ED97886BEE6F4A89AFC2B6B605458EE0296E1303BC02D9E119B122BDA565AE8FA12B3CE519EB0BF01B53B04F9BECC12821CA0E44DEC9F98CD7DD155CC08AEDD04A9EAB56CE6241",
"E0060000E817D0388D9DFB7D44D108F889427D43E644B7D0BC71D33D6BC049E277899D6685B515949F3B171893D827F8F78878BE0048886428978867B7DAD20333E4C8444BE9BD9D0FC7362ECB556E8B43E924B0EC77062566D6792D865E4E0F974DACD457570DA7666DFDC6953A1745EC5FD36E9B5081B3E1C33BD11AE3CD7BC86521ABDD66BA18074761E5C62B034B1C1EE0E85D3C74F7DCCBABB9F0B00042801A4E20375A2D3C553BF19450E47DB7573F18B5E4978560ADF2F4A6F6D99BA5704FE28BE838CDA6DDC043B166456D51E93DDB2C139CD7639151EF10A0E21786A1E2B420643945CB4D2B6DB72F",
"E0060000E8F325E49DB8E001C059CA18401752184F14B93AAB195E731A8B2B80F9058D786AC54492AD4B046B903C2EF4C75602393D037F5F834C524C3B503345C51D74220BF5F22FE4514AC85D1D7CC35A70ED5E05010E205CDB89E10A1A91AE8849D9966CABB94F66D26363BBDD58ACDD55B0238385268C6F688C95C5EA9A968A15EF070D2FCBD82A9645B0C9497315E9A6844A623A7E493D11E1FBC11183E37DC11F2250C40CF4F19F7DB5D95B50A1AEEB05B58B366874D2305F5A97719D55F9A63AAE1E18F8D6F2E966731202B7EB4C8863561775A3B36EF6B84F553ADF566CAA6F07EA53F79450585A74B7",
"E0060000E88BD1967ACD0EF526EDADF72087A72FE54FC382DB87F07E8ABB0CCD0DE8752B648B7F05FDC75E23031546E08E6EF99A5FAA543BAB3BF46BB71030D1601A4B6E04B8F55BD5596096F83312050A6D59D378AEF30A4FE9C594F1A100CEE5B1850397C6F0A0B6B2295A557C1696F2314A17E8E34A21CD984258A2C862B3EAC6CA04B8A4569F5EB8ED22BA8C9DB6A91AE9FC32E16445E378F2B08A5D4C3A2898DE21543109BD9FA0FC068EB8FF82298C7FF23F8F62567AC6C2C247F4CCE766825D097305D132ECAB4D60F0ED121B499F8AB931BA8F5E16C7B703FBF458D8AB80E7C6639D4130F3EC698D5D",
"E0060000E89FA7AEEF75847392CE94A9FFB09AEA71C4EA1CA75F8738ED3D988B8058E0EA45E19B597548FDB31948D8F05F7D1821ECF65BD09C544317209452EA2C18A6D29BC3544B0EE1C54569D8B17C420F7647EB81F0EE810468D27A232E193A6E341755FC951CD7DD1666F4ED387258F4F0253127C8857D3C21ACC8ABF517B160B23CB224A5D535C1419A6A1EFCD3E33BDB9CA67ACC2CF7336B6F99F3BAA8D9CA2B0DCEA4602270B8782E188836DA6A78DC25BA55DBBEDD41494C3EC121402C66AAE3D85323AFA0D0EC903D3BA8D8BFEF2830BF43BCF1742B209E02257188FA38CF10011ACEE873CF6CCA0E",
"E0060000E8602C65A2D12BCDD37C5E165D65CD34410D60DC8E5E5BE62390D27582E41104DE37633878859D705916FD72338D5D417CD2799F2A2BEFF898EAD4726E8F1E6BF3BEDE8B5A9B324E5F73672FE7C770E9B24E87FE78E6F137AC33B0B0BB17559D3F28F05A855663A5AF3CADE345D0660481AA1EA4F8EE576BA7EC1CCA04A563AAF5EC36D5F7FB9243671168E6ACA00C3279B2DAAC0A6AF8D2A8E0CCC7AB390424E8C1D6F7A82A1EDC4D4E797737894C35616F4845B33404B1C3AA99B73365BB0EFC9596FA52A343118E270918BFD6F65C4FAE3983C212F7FF5938D1B0F3A58D5964A691B68E441965AA",
"E0060000E87A7605EA21805F3B2C948C6719D0A005D558FDB55348CD61182426B52C37355F896E3A103714BC1F775B2B8D83F24E7089B9011071E2C16AE2B35C9DEFEDAA1E6303D642E7E48E74974551975357FF1EAE251B74EAB1A35E82DD41938203C6458E81A68D92228FCFD6DB4F61C2E6C743BE012579426353BA5AD73956D391518FDA5320B13B5CB2CFEB0A86C34E5272093414117BE65BBAD77B4D7A7BECE47225002D7DFCE688C3DDC30F55818E7279D507801A3AD275585F3CA4ACADE1B694340C52F1FFBFD3D307B35B168CD9DE710A96228DD4E51156EC9F47E1FF14C6E500A0B79B85EBDA8A3B",
"E0060000E8469DFC74E1535606827864DBD79CDB5DF758AD3846DFBDD71EC82006EA07E5B17D5181CF3B199BBA09135D2B2E2F2D49905E647029A7F227922C415729964D0535AB766231BCFF926617E0311ADC03C2BE67409535B555A2DF67D112464A77B7743AD5D9A742E122CA3448E251A9B82C9A219AAA33672FE8088430935A7E183E775B6A266972D2961BC061A7BF3B3FA778D3F87D3FDFD650E6B9B69C4F2EBCAEF1220DA03A1955709D5ADD357760C5467382DEB33CACEB07DF726874B5D2EEEB41691B50571390D2DFF88A3FAF65F390086B04CE05D659D5AB7ED0525B2C94405E31531D1A50DB3A",
"E0060000E85CF62F71C10A9A1AA3BF6C0AFFD67B259711DE560FDB87974AD204FD1F1AB08DAC2E717DA74FD4DCB70216F847C9F47BEE61118A534E4F038095AF9D411D522B7A2643ABF4C45902C9349A3F20065C070A5000391AF43CE0764C0D9CA1F9D94BC650AAED1F2F1F7B7D0F42E0FC208B7FF1551571E2E181F63FB29D5FBF21E28F251F4E6340361619292B63DA1AAD3C84B80F793219E4C99B5DFE4218C1A13E70B1B9E547AEF618D087CC3CFD6BECCB6F569A3FC5744EE8ADC6A461EABC418195422634A9B155EFCACB352DDA3AAC74C5191601B281FB363D324C68C375BE3103F16F2D36F67C0300",
"E0060000E89E0981D591D14F4265612600049A7A200C0647B915EAEDF686A2E72831A7077CEAC34D8D576F416ACAE2174A9867AAB920A416B983038A81966769704CCCFFA93FEFE2A1F74FCFCB880D21B0A9B4977B87D86E718D53CA596046BEA490D9C06FC070DA9620E896769D349CB35AB7569F629B8718214CA9D054BF6562DB705B1C3EABA020D0769F07B2D8CCAA83E584F8E4A741C370893E4F7800EB8C32FD89D96CB3D367607130B570E1701D846AC7A836CDF169398F57B7C7708B231FD2FEFB0E1D137586AC81D5DC3B15D75B3C85E1771A117D75D882CDE71723D0C50462B6B6C601563E5CFAA7",
"E0060000E863F11159C4A600A2D9CD1FD247A6AA073FDF01FD012089EC25BF7EDD5F163119E0E647A4927D24EF5D31B160FC8065E07A32681E13716947C3ECCE9CBD6F38CC9987B45043D0881DC54AB7E8A688356BD7727C707798FD5F73B1955BEE7E16D917A96D57ABC055004FD9F889622C7E52A9201989B100719DF257C899725366056B575476829C925409230340C53F3426E4BAE9814049FE60C2A20B3E195EB6192F870DFF70BF7021A75CDEE5182922138BB000C412A03042E5C0DAD952BE569ADB872F9BAE92ADC897A8505A0D5E70E797F1B9460A1BC892E18E36E414BA1052F54B624031ACE9DD",
"E0060000E8DA9A741276599377826A31626DEB7788FB0F79922B1D0BBA4E0B91606DFEAB72859ACDD641D024BB5E899B4A416B4CA9BEB3FC2830786A130E28CDE18E0C2DA56879C774F80810496343C87A21D46B7D5EEA06DB9F17A46CE50D44D50B73E4210B16404293AEAAF4FF63EF2F41684F195A11E1F617C8B810A4C9E5E9919A84C6F1A6AE1515CE3572877A50A2E66BC44CC4C5DCAAB15C99FE822A206A53AB614C6DC7971E35A1318236CF8DB28B2A08C5FABB7CFCA63D233D5F4AA28D593D2F53B0B7D18B90B29CAE02368AACB0ECBB2B30DD3E49ADC2966BE024EF0FA513A524F91E57DAF47EF92B",
"E0060000E832F4550F00232B57C9EFC69654BA71AA755EA951764D51E132AE97282983061E44C86A60468EDB3C8DBABF901978DE532FB929A022D48F9FBF8D2C810937C07D22DEBE4D898B6EB53A35E49CC3398F951645EAD3BE454C8A9CD9533F39F62A366E75D935FB53AE8D9D693465C981B6593B1208ECC9FA1989395A61DC309D761EA755E05E4C71E775417CAEEC23A1E26AA731A9EBC10B7A52EBEB182147686FB334A1B0F14B89991F81977D3083E041A478785C1DC6962A412C11C9F09E311EB4B59B67024E6DC2889215D44F3A3EA25C290005DF3FBD57B13AF2A919FE780F8249D748D93243807C",
"E0060000E8257E6E8EF447FF0EC9EA2C2AFF5EE9D293C9E14A73E4A3CABC150B7D4D815E825B91F1D0075516D23C06EEA42C4FEB2BEADFF4B4856467F074D0C5C2DB3EEF14320C130F8B92BB293DF684973C031344FDEEB2FB92D79510BD4F526375C6DFFBB9B9CC47F81219CA4CB07D7EB9BBA533ED3F26A5BBDC945A9BB4E24344B46EBB1F9D457840C6AF315BEF2D9A8027CF30DC90471AAC00058519C490852C606541B8CE5AB1E2EA016A9F7A022A14B58F4D11F0CD147EE7DAF65A648E71D9B72F177E204B8976FF1FF61A1DE0E4ADF686E90608FF62D7F913A859CFF69D5B15ED8D5337E8784FE2A546",
"E0060000E8B442839CE8AB8892107C5E86278F1A8A28A5A80AC0FA00ABFA8704C289BAA70B4C7558BCDD21FB34965895E2CCDA57D3E1711BC096546CCAECE6105FCE4061C647F1F18A93B782003438C6B19DC184ADE7E7E375A34A9AEE507B90D983152DF8D1C57312AA185DA64EDDDB613EEEE8962279B6BA4DEE96E0ACE47FDA6F7E625B4ED64C1796A7EB1825264662B0F7E1B56B4F2FEB23B31879EAC6A28862455D682472F8BD7B11C4E2B2CD009F83751C6AC4A8EE1F18618B4D307306E923E1BF86981D5654E5E07DF722511E258D81CDCC329F733488A103FFE638EDF17AC144A39C1720B2F1B20207",
"E0060000E8694D11F55023E21F9BA73EBF88B8B9E543A7C0219D151E07B0A50F52D5810C79AA6F98DB85C67CD7D791E5919FB8FFC98A8F6BBDE6A49B8A65A04CDD2FB6D6B8B18A4F4A5FD1439444F4603F493C75E681A49429BC7A4970EB126FFCB2BEEDD6DDA0769B4F2CD92F0D802C34916A72AB2706EFBE92DAE519BA13131FC794448F5B1720B29891F82B4CAED9126256A7E02BEB5E3CCDC13678557D611EC2EB921E9F5C79104D4EB58F72E33BB80602651DC99BBDE7ACDAFEBC7B430CE16F75067C270E71EE13CB46C46E99650D199E7BD6CE1A8E4C61C3317FF70016EF125AFBAFA006036E4AE95BDD",
"E0060000E87AF43FB510B96D974052EB0A01E035EBAF5605EB9C7D946F11573025E84F8BB9CDD127042E8EB22AAB4688DF51E215F8D4F3B6E79B267DC59C3D07A4EEF047C892C3A4AB15FCBDCB36C08ADFDD3DCDB1CDC2EDCD70175FBD1A611A2E0B08CC2EB1E1F5E8895E650C3AF0F9D4CAC3AEFDE790233087331C987281FC25A545A2D780684DF52376C8185B1F9F26FC119E8DBB0A66F251F1A7DEF8DAA131CE42520CBC4B3D97EB568D1A9445B5B4293BD88257C7C3782F17B52DD582F36A3D31394AB2AEAE5E73920BB506331C76F9C15604D9FB51C46559ACBAB148FA53E4E193B641A91E42AD51EEA8",
"E0060000E8B011C327DBD68A33C5844AAB5F732E59CB5A4A759B38D0545A2B46309E70DD44AB1FEE0C9FB618085F9CA151ECA6091736D2CF820EECB9C84BF596977811E2EF14A92A4CC12B95656DAF8FABE83FA0CDA32C68FDEF85613CCEAC1D7F9CF851026DA8FD54C9F5B4711441DFD4CA2278226F5C3A4865D29D947CED51E13B6574E02DA875670E23ED5C75FD64E2667AAB9FB624C206676CC277D234464B3414CABBDD2693C13F138AAE323CCCE0E10A6AF0F55CF3CC7C53C56804E8D23939C144254F064D3BD32C74CFB70A7B674972FB7511E54BA0733F7B9D21EDCEC75A83FB56959B4B3DC52D3F49",
"E0060000E8E4FB00FE66B703DD1BEFFEF6EF274F7A4BF0A772A728DFB92650E7748F0F5B23C814D412CAF7F68D0DECEA85E7DED67DE18BE9E5032300F15A89AE5A8CEAE420F4B46BAF11CDC13AA58E0AF47AFCD803A080E4583DCD69F3EDEFFFE6B0EA70ED41FCB656BDCB19CE77D95C2EF05689BC454547D7B8548E9ECBE52E89A56EB1CC5A856A9290A7A4F5D8EF827CB112B00309F9DD127E2EEBB670F17D331A36C7A187E90CC3BE26AE7CCF2250CE5F71612703540BEC9EDE89CE81A42A986999F5AA7A787B32E4190C4C0E622B157407D86E6E9025E0EBD6499B89207AF9D02ADF97A0BC24493DF946F5",
"E0060000E8AE09F1001BF7C99B3EF81877EF2F00E36BE9D882C2A4D7CCE9417F3D0A1C4B8EC35A7EEEF92BD5CF4A1CD85B482E0877EC4B6F8CAFA044DBB0D20EE04D09D54B697AC2C94AC0E231EA5A60FEDD815C85369C85EBD4A916123D8079F5A88C9F7CF10DC49D703D9F75D039A6BA1AD7DF22F21248844FE273DCD4BEFD3273D4E0172B2ECBBB0B704266F0688DABA52ECB0E0EE24096ED32803E6752A89F5A38A2265C83B5C1FAB2DEC79AFC1793009D014BD100C1DFE3FB554D5EF45B8E8CB000EA05A51C75B4E29F9860246B06C7958910D993ABA763166913DBD41330D18601BBCD9A505764D0A5C2",
"E0060000E85A46C856B038F1C7C1D055A3CC52758BF9C07DBE5625BA0FC807D951FA90E0EC20C584AC28950BFF52C7667C4B221FAC1EFA65149E82A50E7493133E8863184591197430B6C97E56F59941EFF0958A26A46E1D8D7C53C0283E8B590DCE21D3B80F5F1ECA94010E070A37C1F5BDE1BC2472AAE487084F7B3127DC086CAA07739FE0B2695BD825A522E3BB389B576A47C7096A0B4BE7A7977941E6F4685E3733A27021210FA2B57A6DA6E474E7B8B1B3525EB46CACC4B2DFDFE1B12700CC78151DEB9CC61135448383650AC5518723B3ADC9ABE68568280B6135CF82E58C7708332B9F1E825D2D692A",
"E0060000E87AB7332218E39A28B9811FB08FCD94F331C088AB6D81114E6B55F94EA9F74AEB961322C80A68B5A4F08CD9CDFF23EC7A3AE2574834E91C31633CF05F1DBC78EA62A694F48C58E6CC5D9984DA80301D84E3A12EA9CE0887D9756BDCF926B247B6A8B2FE58D64432F0B6A953F6ED903834F2789907209EE0A8B9C984AF63500C333AFB2917D5D5DF0888F98223AE3F379FB1EACE027E1ABA51ABC3D945003508065A1BD93722621E234E3258C71891861AC5CDCFC28C2B56E4EDD9F8A063BACFCE938BFA3AEF6FED15CB7E3041060D47B24254714A3AC2DF434638B41A7A7177512A19C86E46B5E746",
"E0060000E83E70FAD7B221CF23DBFEC116EA681FC9FC5F4C2306919AE5B368EBA18A7BF259EAC1F53D69EF6364E1BA4EFDE3C85A605B4BDB16CEBE5B35B9D0D3A96049BDB4439627EF9463CD9F9D227616B40BA682E8D28C81595ACDD027FC3D59FB7BB74F59DB9DCF985DC82075E5CD75BD247C679823B626EF89FD884F6FF529A6C1183DF2ABBB586BB17704F3419D775A5A1CFD18044EFF4AEF19F2FDCC57B205A5F05D3D3CB04ACB8F20C31F06EEA731DCEC11815EDF1BF5E3291B4B7572191EB912C6D9453E2E3368686985D80F532492F7FAA5AE14500F3603DDDDA4B696BBDB574E04AF8BFE0E18F876",
"E0060000E8820E48E61EA5CADA418FF4D505280BFB5583BBA5EA7DB75334001179C87E902075D8B92D31638634570FA4758118AF2C6A6EB35244A89B83FE94CB2D782D7C7448974CCEEF21C2F91491184E86F28ABFAD3F9C7CA06A6064947B49BF1B068592DDD3D199A8D1D0CBC796223AA443B07E494090FD7522BC15868B4F2388D949CE41A7835DF14655917CA6E7D1AC8181919D1D148ED0E2183A6398E2C244204F488BBC4D3132949D9C5B2D131B4EC3F84361D9080904C7EC29E53B304A9B1437F5F160E91CB0124836997F3DEB30CC2F0B28AFDBC8EA84D84BF2F999B8C3105A9A5440BF510C0121D1",
"E0060000E8C909E4807FCC10097E41A1457CAA96A3FE0DAB6074A376C8E5CBB4E079959E95E7EA468D2E7E048988A30CAEE9B9F1985B4627A9FDFF73B3E6AEBECF9097C678568B1DDFBA6EBB7622E11D5D88361029C5B1BBE72B387AFC42DA7A8A0B29D0CF77094DAA76B3A004EC68C9A73F1D2FA07661CA8C27D07D32224E0CA975570AD1A9B02D9F98458696C06E821F9D886701C01A136AEB7201F5C78D7D233FAF6DD87D0515188DDA75588A1531F34D0AAE283135DF12A696A620FB24A17804231F32985F4D8C9292ACF4DD4979BCB6F68ECE1248DA9C0AB54FE4FBBBE7C0A065B1D370DD47E22353BED5",
"E0060000E8DA9F2CAD08826DE938DB2729BB8DD0E6EFFA1F1B593793AF1AA6E051AD2C61CCD17F5FA2C44589B1A680E2EF5627B75D1346DFB8015601762159D72613A7E50F364FEB529C3843C7563254F300A7294DBB8782FF854A4CCB888EB153AFFDFC1F7D552C19A251111EFEEA2A220CC780978CE2992973D896842F3E731762FD31F7C58FCAD50A505951DF4FC1C380E7FA736302BF08CA3B7BACB492CCF3114E2AA00BEC9A2EAEC9FF3100FAA676B54243C50488B09D240ED7B68F801A5F72AA724C7A48A9ED143DBAFC5F095E0790E74F94053E576A3416B5A6C62CB9424B496E45A15F65201771E35B",
"E0060000E81A21AC39A1E6D8484F2BFD823D36B0BAEF81C0F8D523463C8D5E38EF56AE44F3AB2FFAEBFBD6778F4DA7FC8F8EE6F09F8C5899C0BE0A38DEEE7D62682E17E916DAE3075907D6C80EAF58333D5C4F2B8BCE92E8F416FB3959F6C8E181800C250DE3F350BA3331AD0C4846168E0C70F227D943FEA6F4D3CC6826E5FD59F9ACD047DBA350F7416AC24713DFFCF2501642C1F2D8D3330A6C557DB50C2BE3D898257EA3108D98AFCF08B3E194B4EA5F50601B4838293409D2F41127A61D9CE6B916A09001C1E05E12F92573D5F57002FDBCD443A034AFFB1890FFE75BE67D1DBFB4580BE0B1C466709A88",
"E0060000E85B0EDDFE0FC0378FC2721716F9FF66772FFAD45D091E32090CE429EB08D4C6A3963453A0845429D16F2E96B19C797FB81A1DA8376467B986DE895FE9399DAED21562E6B0EAC6888AD6DF9386991CFF41B0DAD6CBA7F2868A62F941189402B5639562C6FE4B5E1F2896B4FA75C0A03992FC566580F8F2BE84C1852BD4400457B7629A99CD3329B1F4617BED183A49B485B1D79FE5F695A2142A0D5464DA312E3FD08DD05BF231C889C762DB8DDA0E3A77BD7CF1F0B8B7CA81A1FAF64BDE23810538424555588436C447D0612C2FF041157BF7EE450CA288F21F18E7CF2792515427BD595405D94601",
"E0060000E81906BD40B629947CB4EED0640EC29609FD9131309EDC7ECD844B73091A76011CE49055EC38FAE374C8A7365453F97A32C6F4FACB6A111835EB2C75E77929ECCAE8A1A1353930733A8AF221B78E9B4F90F7F2044D4AA4BDC0098FC73AD49FDF0A8F24166CF007B41433D2851BFD66744763FB38572782F62000C2B7F899C1D883785D073C4AE8E8E1154CF1AE6C53E41462A6F24A9D420E9AC7466407C2AE787FBA3925CE4D7FE90BE34F9227FF9D33614F6C39A92090E22B74A9ACDE071851B0081E950BC9C4572992D06CE368EEEEBD886F7F48F16FE06F02B4F60F4E8F6993A626B49ABAA839E9",
"E0060000E84B1D6AA98F7521859CF789CE7A1D6755B2F63051A89524C80924447688C3369A8429A07983724CFEDDF30159FC7F961245FBE3BF4C991C1155652B697FDBE5B72F64CD5856BBC776E16B3190B0419678F1BE6A57A314FBC788D36FDB5ACB6498D95EDF9EF26B034D34DAB452D49E00E41D76D9A2E3226F450BED7B7195EBFCD15C21A3D12A343992EF81675A28066AC768AE4789DD1C1CA2D032029A4ACA91D9BC4214339F392DB1EE8127134ACC5A09845FB02248D8D9D2B72503CE6CBD73716A7A0C41F045C9DEAA0BEF0E1BB21FB1684AC790F67FD0C5857BDD06A17CC67748B8F37A3AD80978",
"E0060000E832B24CA4FBC130A590D2C71EDB5C359AF96919C553F8D7B0DC148EE98947DEC441370ED14F6CD649A987BE0C2C5864DB8827D7C7DC0DAFBA58A1B4A04BE89749277040A6929B9CFEF87A1261FFA134F0A360AF9E67F513F6A51C04256DDA2D4061DBA944443B872A2765A6035B35BA35CF67170B4027B10C09C7979D8162844A7777F6522E0A135F16755AD199166AFBC1BED63E76E3226277FE4E8A58BD533F7B71FD3DDAB253199BE927040E6AB3B6E0CCC2664C737E306B8F74DFB05F92BDFF3EF859FBA5B931848EF4A02728428D535B9E11B4BD68BD8465894901FD5B42B2066CA2BFC1A2CE",
"E0060000E81A828F12DA31124F669028F03EB948AF88A1D7ECF3EAF4947ECEE8D9ED48C1CE0AE33A3A8AA878C294416C4C784D5C27F57E8C277DE8DE6C36AFA0DDB750B4548CDCA7EB54DE7629815FA9291E72341D3BC34B332717F92A8552CE19AC53132ED49E9707C4452B68E7C0FE0F27551CD63570EC26FC2787299BB82B017F79927143A4C29238979D1DC87BE7EF8644761EB12B1FAF2AEA17A160C9085FBB5AD59E94FCB3B9A8D218FAB10FDD2DB045805D51E961FC2E3BB93326F2F49370598776F30E9680DEBF34C6C55A74A0744CC5BBBD0CECE4F46B5FD5B61ED5EF2F1292E1D571B3BC53D56688",
"E0060000E8027883B066CF484E5D6AB062DC2DEA9053781908FE8870FECB5EDD6114D3A6DED5F15A08F58CC1F87B8A1FA5714E0FF5C08DC22ED7C960736C9CAFBD7408EB8873312993BF66D755576EF2DAEA5AF535F864CFE5167250D74F53B228893756CFFB629E71ADD7EC1731979A3F91A3C85EBDBC9C455F43741F5BDB568E5E57FD0AA96B924ED2CCE016484C22464B5F8E03C59BEEFBF862BB553E133435E52C1E48991410BAD9525B1B9247CFC4C3336C123D13B39B27B4C3FD90E84B0419D94BB41FA2F3AEEDEDA2725962B3CC6EE5E3387A7AAD982003C51E1C911D3A1440CC674D0520EEF28899CF",
"E0060000E87E8348A0396F4434E646192CD006AE825142AF55D7C4056B5C46C6BAE1EE4DE71B1BB8C63A7DBADC8795A124139EE3087E656821A7B65B00743EBE2705997D2C30CA0B9FC86FD07177D6D58F8C5AD8C9B98AA33B4463166F1CB0E3E9E4B8DC198B5A67DAD865F706846DFAA3CEDEFCCB407D6C7CF316E1AE91A4A78878772C6C90678F659F92BA602D96048066C9325DB2E5650EFD839A367A8D7B39B60EB61F7CF6430E50C4E7850339BDB656BC72C7B8EFD660EA6F0848F692025EEF3E95BF331DA0804C2A92E6EF0275FA8579FD4B9F8DD75210FC9B9CD586625B61E28D65BC94046818157417",
"E0060000E8333B4F6CFF450D24CFEA604BC48AD78F91DB8FF2F60DEDFC576EF340EBEA6B3AB54ADCBA4AAD594B99BDB94717224E710D473207AE92682B4B1089F83775231580BF05554BE8E7598A6ABD432324E858548BFD30C560167806A3F89EE2F295D15AEF3B6E640AD0B0BE6C778EEE124CD7BDD2BB4DD7CC452AF0E67F839FC99B6BA2B2ED316F8AB6C2E821D9A3745D8B6B032F8097FE21FF6F9488D8B3133B24FD3D14644225B03636476075BEEE50675D3E168BE6A2C3847F34BC3EA2BA6D5BA882973BE4250BEE3E2F4BE343A8CDA086C9C52FFBDBDE3E9C975001998B4523C6C3E23FEF67EC7219",
"E0060000E8C3146138421C9C3A2F1AD642D6AAD56704039E8726F78C09F2B16831157C2AFC36F91A05286F99436CD8EEA93F087FFADDE060038424809692B444DD9654AEBBE4B0C9E05162E3C870A0C3AD4053D5FFB779E5543E64788687443423CED5871F645C587EB8A681FD819C5B8841E3EC8482C5C58345F9E2B1E83362B8F791E1C0475F0B755003A6560CC34EC1C2E3D26CA4FCD923C3092015720E05FC97D1D879C0358409CC674D2F1FDE8FD20353957237EC291EFF449E048406EE33EAA12C0EFC15E82B100DEEA17A18AF69B12B8B74251D2D4A3680DBDA46D03A2DDA2A8B7AA9B6925160FE0D66",
"E0060000E8B162B19B48D0129930BC27BE7EFD1291D6B6583686E5DC593751CBCB38A46F89243E3CDD8132EB270D20E37301E0100C80445E94E10530C5AEF15702CDA47B24F9EA8A2F626543742D6658B5780B7DF5C16E83A61897E030BE7C9A02CC789B068D81D83B075FA29F6D9EB46D54E780C8EF607E94D1CD7401DB4F0121E1C398BE01991A85B0482778911685B266D354D5B43BF13852C1674E502D0CA783A3D00E05501BE7897F8B8CAD9F808D40DC0BDD8716B3A517E30C48BC3F1CAEFDE87B52728894469AE2C6B4D94A3D833204931175B0099D5FE4581DAC10672C5EA2AB7C1C3AE6DD15A478DB",
"E0060000E8258A621916F138EF64440210EE91FD9B7FE31FC0722AF08EF392B193120D09271A624E72D21B59B6F9BDD5A2F18329C1704C635F01219AD0D4D4032F3FC0BFDB685D3B8F6283B9BCC9937D6B4C4C6598C495EDA414D11BCFCB78615188BA887F62894642E471BA4FDAE72C8D037B981C10B8EEDBF8DE6BB0540DBFE1BC0C750A80C404EB39554390D5D7C68B9F9DB60DAFA5ED12545DA823B75337EE34EFB02ECC29D759CFB8472C703F603766663AA5C107315CDFC1C5C779BA41F6ADE7A3BF063D0F4CEA0171F8A659309FA04A5C96BD13F7F80F25D29F4891A9D1EB899DB6DDEB2E103D59ED62",
"E0060000E8724BE46F499DC4338BEFE8C7CC3E8500801F5AD6F0A00258D2E753FAEDA022784FA3E9BE485B744A8938A0366F755F40C66ECECE33C6BD56936AA4C508B5EC09E8EA95AB1CBD8B17648BE571FA36F54D6975D14A2381C297242C6BB5B94900FC0BE77CEBD15B03EF10A113FD0D3E2B56E07DD5C0B386B8CF933F0D1E325453C501B8C7B5C73E60685BA57BAF5C029DF8AAB0CC3AFC3433B9C3A95D0C1E273CD26A173924DD763E7CDADEC585F9396442D18460CDE037BD24469891E0BDCC1FE78984D9C990527B1B655EF5B5620E6ED63036C5A39036A37CD7796F44389AFBCAC68AC0E1141304A0",
"E0060000E89948A6AEFFEC85A968CA59ADF2A55AA16E280619FA788BCE75C323E08B92DBC5F8905F353288DD02F2F69A2F5471C44D7BE6652F90FECF77857834F122C63772FD4745A38176BF851335304EE665D9E036785D0A304DE6ED3C4A58B681C19DFFECE4B8B4B54F33F3D6328BBBB0D17BCCCD27CD01B495A05B5F47E8D82248212D948F88E9A8F91AB9ADE5DF110E70D8A59D18E412CBA6B5C2EFBC63FECFFBAA5A7E5046B1DB96CF00FFAAD123946397CA56595C3D9742D829D383B9072DFA9F420747D00D23F7CF5C7016DE44C186F77235D49037F0BACD8CC4463367529A6D61669C294D541F4932",
"E0060000E8F5A1DC6901FD05C8B1A1372CDB1486345579508E99C5AEEFBD6DCA10569EA0BC76C57E52AF1B3F8B899D1F60A81FE0D8BC20A88BA64ADE76402FE094F7DF4E9683A55F69A4BAECBC6E93A7736C940620E2C791829D81CCB68E6B8D4F092D7C8C4CA9F3F68C46D00AAE55A1C3AFAFD3C189EF997ABE5C3F1EE2B728C69E994FB9CB2C6B93E09F8A8BE3254214F4EC069ECC4A1E20124CF6D8D700DEA2E6F33E296E3727C4AF11EBC65F1A7E28C03B23C66664E6E6D4E1C6716E26D915520DB304CF66153A5B290B1064245ABC4067DA27388CDA2CE4E644234D155E6841CFE4FCB2549ACB79C1F618",
"E0060000E8372C390AB6DF37BC6D3F3A0D5D3B20131A1C0904E7223A8A3EF9FD4482FDE5FE795309C30FBD177A6EF929D63D9F79FBD7849345DE754622F173CDE418BEC2EE704F8B21868CA1547FD99C76BD716FA1D43B9D6CAAF2EDA8BC69F0B00397931C7C3BC35DFCA7CAE0E993910C3DC49E6720DACE0CFCFE651B8151D08F4CF599FF7E127274F865F0A13BE9941E479FE5EF3941B77D275F1A9AE6FE242C803582F7C7761E0491C1D1D700C6A1699ADA85877C0535EC92255D2212E74A3ED8D7379920EEF5B0904B28A65F8DDE248D8F5843F672B975D086D410D287FDF2D105567B1E87BF94B548F891",
"E0060000E8BBA1022776F5D4C13A805E25ACC437E1B24EF1C074BDADC7BE981991E435956D57B7535C973E9238A8BAA59DD58793C1EDB9B8C530A93124BB2EC12A0A4AA9F2ECBB5F2648DE434179545CB3DE24241C3D32E8241017DB848F9FED7BC35D48944169768123B7EC02EA3A55F3ECEF4F8DC2013CD24EA5FEEA9BFD48A25B40F84F8AEF74D10D4C2EE7D54FCA306DF45409750FC4C672F3649DFA30FA669A185FE2EE11A0242E3E6647600F7CB4FA0C9A4D5614115918659E09C3EF8EC00FFE7237A6CD3CFBE459B502883AE1EBD6A1E6F7934AF112FE264EB5554F860EFFC9DBF7D5BF8AF206A221D0",
"E0060000E84E360E9CBFABFEA5DA25BCB077C99ECE4E80A1DD8B41BBF4FF2079E35A721A4101E5D1B8BA2035517D0F53BA93AA707AD9AD04B49D6ABC582E7F0A5BDED55828D05D6AAE456BBE6891011510E92D3059BF9BB530EEE07EC76D597AA183D4DE64BB1D401E6A3B5E0B06A992A425F2D6169D92F962916967060CCDE92E8687AF69C376EED831CAD192702FEEC83CF2FF8216289519189BD766BD3FC097B0C5C5E8AB5A2840AF4CDA6018852B397D7715445111347C2DCCE6219AC19BE7B8B37B33962861C8278B90B589D48CAD1B5033A1ED24A8B5CD7A14ECF01B8C4E3E054A311803C24C9DDBCE4B",
"E0060000E82CB2EB5C63E19576B0DF69A40A0EFA0E042617CCA16A3876B5465DE51F18D91A10FFCC66CF41C1D0C0F36961603D172D1513279A217E1183633415039E0B2D1C4CA546BEF14EA1D31929A0A2B4769B21979029A3C369AB3AD417A8AD7C147CE217C22953A2CFF80098D1B8884C10CDB6B32DB9E9C9CE77F362A0A839F5F5B53C5C39F74131FA9E46599B94934BB2EA7896645A3FF537E4C6C06A197B68AD8DFC0F6A7EDE8793DBCA3DBB8FA07BA1C2E07554FD73D5EB3694E9010031D8CD26F36F262FD986FF68C9B18499803E467FC6C0ED5D35611C810B9709331186D966EA2C04703AC1F78D38",
"E0060000E87997233CF08D409371E37361482E782EA382764C1493670F09175C2795B025EEBBF606AAB67B5AC9E6EF5176F24B0900CEF7845D03DF6BB5219629789334151819F765FAC9095C3CAA5C580A1059FD564F16B0E98A741805C27C7D5E09E211F49A9112EF9AEB45C763F8154170EE99C67DB63E4DEDF8160EE87017487353D2C38C1DDAC4C8B3010C4340198A1190CEF346CB0172A3FFA8A4E0A19A36068F01EF7613033D4D6AE8E1A684C9DEA38B9886F4A62472AF9BE214820E476E1A8D6364848271782398ADB905930419129899974C72F975ED9910BEA5C188410E571F9EB287394F24ABE937",
"E0060000E81AABEFB5E5F4F64D5E3C3A2626D6BB76379D1223150871E0F30F9DCA6064226671F5CEB79EA35A2D6184D974326FC22CAE21648DE58EAB5F266268FC93A34B82721AB3C30423F0E3E7C571896058EAD6FCEC3BF129F324DA0DF171AFA4A66CD0C56C5ED781943E651CF3B7C76C34E26599F8937F8F04EEA444E3680D4C7EB0EFC31B6260F1116B2311F5CD4D67B58F5C317F8E1015CD5A71649F08D382568E53F6B6D19C8E9B81E57B3880EB2737E58AC83A880D6001FF2F0F3AAA1A8E762C57459C70F56C9EB2E0221CF5B998179CF6758C67B9167059F96BA6BC0F2507922282C6291FE289F83D",
"E0060000E80EAE7BF12B28607302EFD84FEA9E85F96FBF021D9069622A2C8436C332B1C150A8B0A0709A18499E2973803C5C6CC91A259AA552C4034E61D74BE3DFC721908D4D22C3FD3A09AA6DBACA340D16D39312821E6B13CF38FFBBD74FD5DE35C189366BB7533F51D82979AEE39C86149FBD9C64BFD7347811957C2944AC24204E6FBA9E144DC49CC5CB26E0156775FD056DEC079D9A3F652DE2B77063B2770C8364092C1310011F1C6F9B7B8E95F67C96C6CB4A7E8D11D8BADF1AECE9B829429B683071091AE812D710BEBC4B3645569CB357BE826C7D26DA5166E30EDBFCF26421E01120F755B62E5726",
"E0060000E8BD882EF3FA0FD5B389F95788512AC32010044E7C9C7E81B3A660B9F10D88FEFC2383630D253858FD4939DA1DD84FBCC056C055117DDAD6C212EAC5102EDA5B5777299035A9B9D2AF1F01511D8643DCA11768845000BC79257B6A6B4049DA0422B0CA2B753C5D3A8C52EA2A41ED172DB63D5194EBA8BF3B073C2AE9F0CCF24DA93F7488CB3B98BF3BE20EF24A0D96F9213D7CE99CFC29BFDD766F1FC1F9DBD89885D98038DDE52754CA9DD665E2BEA1E749127703F4647514AED5FE9724B302AEE0B729B84A339F00242AACCB6208AF6E53142036C8D6DABD70C6F563BA6317FC2E1CCEA5EE609223",
"E0060000E8409A73DEA938A0192B8F28CC3CB9061135892BCAF3B9C4650DE9CDF15CE3237B48A710CE66A12230179B4ABDCE70F72C5B129CEDB8D8C60EDB19B9A2E4D586786259DE6C0D0AEF50DB46712239BDF23BF6CE7F6C0913096C30F1D82A90A5D781311CDA5A7A5120668C5306F4542F8FEAFA002A6A5D8D6D82FDB8E006FC517EEE4AFD944831FCDA85E34D1FD092DFC81218898CB91F2028F924EF9579288866E68D63F71DC01F866F23F4893F123CCBDC449E9F73E8EF0FEC12972A6DAF9FA8E5C1C16484378FBF2AA443CEF6F74596FEA4D6573AF6A7B5D7A6F4678548875E8DB0129972EBAC43DD",
"E0060000E8B975E180C49E370C9B7BA67DA014B2B860D7B918E54EEB2AD6791152CA516341D1F6F136AB5FCEFEBEA59E2B3400FC15ECDE4B8AB08FA5C2A6CF19D2EF461ACF268DADD1D6EDA4C30C593B77CA1DCFFCFE984FBC9ACC8C8303C84CAAFA4255F9974E958AEF78E8576488964C80A895380254DCADF07EC443D340C0CCCE0FC707FCFC319DACDB6982E66AE069D2E3F608779F3098787C3650F3DA1C1EEA83DAA0E3D7E7706BB04A411EE4EBDAE8BBF203C4F0566E9F7FFF32E90730550EF328F3E6FFD970EE5EFB9D0442A027F472461AB1F17FEAE289C159644DE699E44B01E20EDFB75F3F62F2FB",
"E0060000E80FBF8BB68760F07863887284C46C4B6E4AB08D692813E818ADF4D1AB68560B6B494F9EAAFA1612EA5E46F4F5A5B43876905BE92254B9C29FCE66C54A5A646FB0A3CD862F26413AAD049973720323E4C6111065C393653B13D1A3435ED5C61AAE6B6BC54BC09A2B9F3088EB05FACA92112E96285C1F92A8894F9AB73F8608DAA66FF099BA858D02CF2544370C1DC5FD88F4A16998346E1AAB92A4BD69FD9F4F749CEE3606149D531D9EAA0171C1AC7F9E96565BCC71EA45039582441D7A565A1899B2B8AFA1F5078E43E653BF6B38E98C17F8E9D804472C1B00D9191235F4EF2EF93F9B7FDBF1CF56",
"E0060000E841C48594EFA419EA765A21A33597D27BC7BA804D51D9D310C328C3D21ACBB2790831C7F4C0B4BB3AB286D3E110BA65A17969BB86A59BF2A83DC49DCA7C554880DE68C4C30D45D2B20BCC2BA004859C9F3C93572FDCCF735B84E9786E1EE9C877A42B56F8326B38F0DAF9FFE036899AD7E737605C9F88C6CB2D7AC296630C128D38B77A010163509A31D4268CF8571645E51D39459BEC562D858F9E086E30DEBF632A4670A209D0F749C725E9DB4F614C852D03C380DAE8CAD6BC1421CE843B0E5475B737D3CA86746A3CFB1985FC7E10F551C3B5AEB8993D0CA36DABBF6373FB1994441C4402E844",
"E0060000E82BD27B759A3EB0AB8504FB56A3AF66134FAC4D82530EB83B170079D39F8FB2FC0B85A03D6069EB9BEB2E2D5C59DC9C76981A49F12CCD66345FA5A938F50E1AF5E7CB7D5735F8123DFEAA7081E78D87DFEAD14D8C75966B18F5EA1FED4B8C7A5C10A85104617C08F29BBE3E916D4F289000D97124B3968F5A97B15FAF946E2BE350BEF144D59C52028847B9CFB1355C8914C884BD71E4A81924B034C5D060DC30F91C863B33F3664BBE0D083F99499554EDDDB82C660E48F31B8191B6110A7DDF343AA165993692E02D6E5CC1E21763A9808F18C37EAA670334D500F35B1A42894F16B309E36AACCD",
"E0060000E81AC07B43E5DD1195BAD4704E123E14F24B0570203DC5EE4EA9BA737D47FA6CBA0FC70AF41D9EAA37BCA1BA2223EFB4DDAA176BCC22B183E65CCCD64FF32B1003165AC1D46AEBE6E3D1240D1949E9921F29909B9CCD3C8F9E2B6A121142D4AE98965957246D24510CD81CF54BC1809A63089BC1811564D116070717DF13C1E0F6B35C1CBED75BAD011319285E7A8BBA53CA8384EE31BD68CE5EE1BB21324F72AAD9CA5BA5827B78DCF1982BC3BB8C10B6BEF1EAF99CAB1EB1E564FEBC7A65F838457CDE5AE41A5790DE1159052592C653723F4C243D74C4EDC5BCA762B32A8EE475FEFA14E8C08A80",
"E0060000E8D2C60F252BE5BA06758E8EEFEBB583FFD91D79DAC04568E8FBB50C275F8B2F0A61D7BB86E60EC122322DB021B17CE6F52FBD82876C7CD19A5C52609F80D8B44B41CB948B939F77BA29C1BF6253525A748DE04C7087B5A1EB55AED7066A94C45F647577BD5AC136166F5E2CC25E84BE9406FEAD5A7A732CD23704BDD7020454E1355A396EA844A96D0A764D9D880FE5F085B7F553B2752F5735C8EE0737A0A7EDEB08AA944737AB2759C8C50E316ABD09748903FFAFBBE5B307FF539D93B4430AE0A60181178721FAAE65FAB2C878F6D106B7D7BB79FE65D8597FFC8AD01E8F9509B2DE6F821D2052",
"E0060000E80DF4D36A1BF5F51CD6BA150776119BF5DEB386FE35C943241F3292476AB5FCF6BEBE7791286FE87C4BB4031E6DFB1233E615AA88390F279CF474F15EA477B6120509B37D72A72EE9C5977A2AEDE56790BF2340167AA1CB119FB01DB10DE496B2612070DF280200777C6C5817518EE5214587DA9D06F075865250134B0D16B72BE424A63C66953D0E4BA265D34368BED3395D2B24E2682F1737EC6682577E54B40316B0C4897A4E191B32241381067F5F554E79D2764D31B362EF241636B107C398AA22AB543D024F5D9BCC05C47D576EDA6F7D5FFEDEEAB1D791A8A37BC29AF0285DDB60C830A9F3",
"E0060000E8D3CF6B8A4CFBBF7160028BF0F9A31E791BE696E5220FA077635375A70160BA45056E7441059E5B185326EC0615459EBE5FD64C3BB2A40E8AD83793C64771AC3E397B5F8F0C9B23435F551091965E75B3D6E5E8A5892A5CB0781495B3BB163A911A7F02370DE1FB356BFAE086B3710F3CDB391126F9295639216392A3455CF27BD4A7FB79108D082F54F0701265CD76523E2D7EAA9481E261D7D45EE1FF320E86CB36CAED71B9FFE1D6ADBE6F36B02CF70AD1D26AE728CFF9E5A24446A4CB2AF402C6E59EDAB37ED00957047573499E93CD31DA9CDCA7CD9941633E3ACD64E75F999D80E0AB2C3179",
"E0060000E89EA2145B1DFC6BEFAFC3DFDF43ABC7EA694DEE335430FE9091833B13929147D7B9B4C63A177AD220B7D249D9F233DE588B2AF5CF038B50CD780566493BF129AC0CAE41C01416B964846B597943C449FBC9699FBAB9FC3362B28C14D99946758821E2546E23B73A4E95414A84EF6C1FFAA8AD93214FB878C19118CE4B85219C9968BFB79B44AC3996DB9CB660101BB0CD1E5A1ADAD6A9991A06821DC3582BC24B5C8D5B0FF16E33B0DCAF779498450CA3724551068FDBF30D12C0786C19FE9A42D5B6128736BB3AC3F28F5EECEF16AA60B0E7FA8C69641354D41C14AFDD995E09BEED18AF8AC9C428",
"E0060000E840E127A48F26860B51793448E0B0DADBDE4CDCB718762E1926F5EA97659D80595185489ECFB384ACD7C04FAE965384A05DC6A88B8C4A7CD7BAF990D313C97515C08B92C7340E7B4C675265B82B74FA27D69BD7831B55F11C9327BAAFD0E52C279B58C2C2FB23797320DD3729DF31FE42339CAF81C8910A1A22224927A7A928BA45C8497370E66CC8781CD0440B4DFAC1019A1DF22F29B6A724CB369061BFEFE8911A84B4C40ADDF17BEE33BB38B938A48893119A0078BD993A7FBB31A1B94DAF2448AF2D2AB6438E7CA1455671AECBFE52A7D4807B4E57E4E668C2406FEF300E26D55F33BD1017F5",
"E0060000E88EE644C8AB05DCC010DFD429346D26774ADD87F67A69CFB390103375CE7F964B7D6B612F7CE8ADD3361B15739B6393157529C83FF6D077D61F92958EDA6F2270B52522877D5C98958324BC93383D5D648207240AA1A32632154B1404C587DAD92B8D21058B1058AAB0EDDA82398AF5C700FEF7E8D2083079345D7436C430A5BDC4BB56D8A1B2E030BB6BF50A8CD99B2768CE2D7F4084E54BFA12CCE1EB65B156D42CACA4A23A3358DA872DE33ECD4E270F3A97D871BBF6DA9BCDC8C95EAC7B230F6B166F602785DB326521E220CB8D78E8A34047D4442C24F45426B54EF9FCB2C1C7BCD27C047370",
"E0060000E8EA09FFCAAAF605370E9BA701CE9B94BAA85119445F69969C7654684A5D773727BC2867FDFD11E4499ABB89EC143ECFBCCD1622BF29D69DCD535D7146E1DC59EEC5913256F3A74A723EA5365EA7A995100462CB0A153889A285D7ADEEEEF5A0F8D2F9372D0CDB906CD036B8B0C77E9C8C5E1CB864C3A003CE6424242ED561506B066170C106F7E2472D11DFFAEA8AFAF5C7671AA48584D7394C755A6099687CF83D96D52875F52143783838A1E7D682D5798CB1C99F97B82B62210A1F68B7395A6099991858B27FB3A2067FF4F5896FC6EA2BB9EE156F55DEDB808E946CB756286FB335F04DC5EED1",
"E0060000E8754FB79E5C4FCF27038875B7C113B18E204479114A244CB7D18481CEFAB62F1A5168C47890E9F1A253266989EA5D1E64DDB3263A3C8C1B86B654CDB92D18C8E6F93C92F1231469BF57A6E78488B5A30282084AF26ECD5B1088EA9BC5D40EB8A31EE6BDE307DE7DEF24C173731D018E7328303ECAF285E2A0937E8DC3CDC02C739B85FC232C37460C554A0C9B1EF720D96DD706067AA37BAF40DA7D9857C0D42D82E62CFDFAFC0DFE49883AF33A7A976EC9ACEA0152F401C94B02C80E70065CF85AF8E0664D74D62A1409F399E1A637FD6FFE49CA4258FC3F4D4CF9A277DC579A88AD42829C554A78",
"E0060000E881C12A7376902EA247568E545EB580AD88ADC834F1EAEB17EB5A7683FEC7923AC84A6ABAE28B32CF372FA126581C421D2C7B8AD8E4CF508277BB86F81EC9F41A81FC1B71B5801DC80FE527C4E1B1E84E769EC8991E0EA1114F1EFED14FFFE329C4960B31304910C477C0A8C89B5998BB95FEC3EB12B1ED9755B47264E22033E89D6A35C2BD12A666444A2E6A4759CCD0BBFDD86DAE15D627AF163E60A4A62D2E338345D429CBEB3844823145F4C0AB2D93D963017190B8A0D7EC808E448796B846882270A135B67D0B3A666DB0A8F4D0A4FFAB79108A5D1AE4AC560C20C3C64A5632CF4A411EF7DC",
"E0060000E89DDE0BF52A6AB26B0E06BE8163F29C2800B3ED473B384E54A0B60A5D643A8A3F59F70FE2CEE1FA4952C094A706416D13EA3AA820060141AE62042C22C72E9D132D120529F66FE4B0E1F9309263102D5F59745EEDCE502A273633ABF619367463AEB33F6262EA6410D825460DA35412D0153E682144024EBD23F8C73C29E6705DD4116EADE1D1824468CF6DBE53D2E5DFB211CFFCDE1FAD4C606E8CC749B7D213300C963A2E67754E8323A8B6CB1D15373146D7895505EC243F38DBC3EF0F60C956BCD6A184763280D41E7A05C675A4CD6B46C74266F7846673EA48DCFA15D0110AC59BF2FF108D4D",
"E0060000E885D4497D7011C352C9392595345E458BE3EB663A3C93CEB49CDD2B3F8AAEAD4920EF451CEFBDB17CAE1795AD3E0CA92AB1A240271BFAC1121CF2965827ECE31AD73C6A498BFBB88D41B95B55A3E297A6B52D3D560EE6D74900C0F1CD8AAC0B14E9F9D39FF575DFC9049CE79CD34110F59CC80F70532A4E1CE82BF4E45B451B7490FA00BE91317563F2A883BD9DDFFF017BD8071334302D58F54FF60E2BBB94563857B8D76D952BA7138FDCD76BCA92319A0992241108718BA50D344C3A2199D43A168A9C11DF31DF543F7F9721F8889777AFBDA8809BDCB36E6ADC3A0C9D66730A1D8FB7831A23B9",
"E0060000E85BF6AA6E4AB710D1FE3C380BB429DEED8FA93605DC86037A1E049D9249472767F169A9C88137F0D4924742160610920D02BD41DDDE432A2CEDF18C6AF15779841D681A2418E37A0CA63FF8DD57C257646C7A8EB2EB6BD6D8A51AB4E69DE0C95B4D224595B9C70878AC56E17A76B5EB89AC483283C4D14576FA6C9A314651A1ED95F3F2A6B83FE14DFF3677E4B80250E7594B61FD58E3F263D862A1CAC8FF9FCC36C18D6E4B5F14E6B84816CF187F3A3DCE9E608E9985F6B0B0F945577CBB595447DEE6F310C49E7C9E30E2BC651A8106A4AD0914B4F066893616DBE817270639D2EB663AE3FEDDA9",
"E0060000E814539DC785C88DA9E994CAF75EC7B63AF76F32F142732121761898B824007E20D0426ED48EC6336FFA899B1586DC17DA831BCDF2D09A7E827FDAED4B935AE44014BD11278B0D0BB212B85FB734A344D6535ED3A9AE0F329037A6D7565B67181E133BBD1C86CDFCED16099BE00F3C469D09DF861464B13803E1C760339E39301704C882BA8E5D1F9CCCBAACBACC9E0EA632E0DD13591277C81185665B1473D0857C8E133BA26D7FBF6B4D585F843895471FB7D775F985C4846C08F05677F9638FC63F3027BF7150F7E9B2585E5873E7E03C2CB1E17C3814783A2ECDA09EDFEE1BDFFB7A2C8F9DE129",
"E0060000E8299B3BDD70A2070EC4E37948B2A6568BB4EAEEFBD59497DD4DF4884DB4CF006D182C89812B1AF7E269D9CBEB55892A41A826CCC88297BD3AF6D9A0451A208FC0B48621565E253EB589BF2134F4909D36F693FA75D7C60591D1FACC34C144022BB16166CAAF1B3CA182DAEAF68A8FBA164CE398E531EF90B134818F8B19143C8853323B16B30E49BB07915A1495DF9D05A689AA9C13D966097AD1B7BF87978CBA38604F403CA60493BA6EC8DAC57728B5A4764916890370D5A5896FA2E39F1187BFC81B005F91CDC7F9027A6168C7907C083694C50564B69DD4632FE268CC98F2BB5ED7E6CE2E59D4",
"E0060000E8D371F718598716E647BBFFA087F3733D9B899F0C8D1E432322F3A766C4A238EEBDACEEF338808181DA1BEE60788C032BA89F26785EAC5221554BD404408CC5FAF22E6D4EF1CF05FA8BE511DDA54F265450C538E4E72CE4CC0845D8D3A7C0F6884533115300189225C2830A533434877FEE2D0D190F3335F0C35E3098CC3F7672C1F4CDC66585AA5DA0ED040973332D111BD303F1E9034173969BC94654AC7CC833774B888E2271635057208F62CFFBFCF2781892657E10F3F12B96CAADC430E142166D3FE316DCEF4AD3775F8DCB7168E83933690421D9F720579321F9FCEC8117D577FAEA41E2C8",
"E0060000E8D62FF3A8129F12972F79E551C528D42B50832F5A9DD57A92B224F5A268B1A51395F87C7929500EEAA4D6E81787382BFA58C3B1B1AC073E4801917C23916B5A08958FB0AAB1E85D9614EA957932849BA8BA25F5A5AED4FA3525B0D9A2341EB5D71D238ADD4276B12A8B274209829ABE0722C033BCB633BB4C083D143FD18B9D86B877B77D00372E0A41B84622CFE3320B5AFAB710CD6287C7B3E71836493EF2A0B09351DA4B51FE59F40DF9432D59D5E7F62262FDCC610239B9274FD38F54710AF801F6032808297505ABEFE78EE7E3E3E81D54BDB456907E61073D060282EF77D3BFB34BD2A1FBFA",
"E0060000E88D23AFBEED54314D629145BE294F3A3A9B5628C10C8FFF29E506630EF2E6D7C55228127D8335F6AC0B2F5BEF3E64CB589DF61DB16E8B9EEAEC5B85B76D871BD0610BC49456A2B784A0CFB7C261C333E8BAEC1832F2BD4245B177DBE1A58A9EF3C91D223150DF8FA539474BACD13659A1DEE8DB1CDA8D2588853CED1D45F09B7173428F6128FAB80D6835C0236EA4DF1B7014608AC7635C2B68028678FC25BFDA6CDACF297D908572513EB0C80AB4F712EBEED2977CB27C2A2B00107FBAE9E1D803AE1DDE38AC753BAA4C7F3361E0506579B2F7DCB657E5CECD9D2D826C93FFA6756A0C6B41056206",
"E0060000E81C85397F2216A057C8FDB7C390BA64D836EC58980020037E26DBBD159D230146359CC8B53172AE30A6CBC3C8487A6608151053DCC772A4A669CC6830FA1B6004CFA1F9D1D8B0820C191D7E47FEE13DC6BF27090B2EF86C16A793FA041C6EFEE7A492CC76CAE735BF6BB9DEC803CF1DBD65DBFE626DAC397B31A68F781B994670775330FDC91059D751EA5CED974E4CC786A9DD694DEE1478E0565AF880F61412898CCE9D5E78FB248FD822864C9286B22FFFD01F9EE27446DD6FB68041EB431E0660195456378F29DFC140A45D8DFC4AD8AA6B9AA4ECEA2EFF1D72BE2F5F2A28CF2D3493736BE797",
"E0060000E8FCE1F26C5AA82E05616598B3288C1867E90F1D819D2BA7557F4FE9F07ABB06625EC73A885BF1CCB1FE50E813FB71C2CAEAD243DC107499ECF76DC13623AB775FB913BEB4C899A70F6BC48DB0732A5F8EEEB2FCCAD77946C5138DFEE5876A8DE9A530B9C927C32B332CD4D217E4258BD3E7672C3BFAB0114613FD0075D821D551A4B10BB3DBDCADEB45FF72A836F6ABF4DEEA313DD8F789FAAA4313D0FDAE5FC3F8448706E1F2E52274D0A4A72C44AAAF8721498E3B9EDA54F053914A3C7FCEB610965EF10BBD38A62349B344914E814F83B362DC567FCC2E13526EFF1A72DE6E760147E71CE6DDE6",
"E0060000E8CD356F78E793B2B7DA4E7BA1E7FF6E13A8047C109ADC3B4D43BA1BE4258D16D72ED4608083CAE0042CFE5C61B7C768BA5861F929D43EBA381ABED7129A143E483E552B27EC7DAA2A8A757D630511CD05E685ED36AD79990233BFD09691AC8B0CFE83630CBA7B13A9CC13BD2A52F7AB608FB9FDD91D5117AF0B0E0A6DE5814EB4B325962377E5A96F82D95E8C7E151B7668D51EBE8F6F69B60232E16410D4418532767227837F86E09C2487E1AD57673F7D666FCCCE857EA9F163A7C29D5948E62FFAAD704E6DFA05A235295E55EFA9B0E0D8D5B7462A7A8FB914F16DCA6FA615187F2E24C4960A1C",
"E0060000E8A79830BCC2A40E20221F295270872F990BFADB7110EA732C79AA6E7EF8FF8CCD7E21D7B45E340CE58D332EFB248FC87C95A61FF0C52960BEA210FD0A189F8AA5D8E2DA40DBB420408EE0BBEF15C002E974C93FC6695ECE42C4A97354AE516390B015303C206621D425E7487674109A6104098AF74366E7B1A1C844C9A4F03B57FEE0F61A05A29F33AE0713DA25490055157F7BE47D840E2BE482BA0A284EAC5C870D7EE27207954CCB75E98F61E838DB77BCB97A2BCBABE6EFD3767094A549873C05C884973EF87264C840DB3FBC3FFB0511888B368FBD21E2D76F3F34738D4757169AAB2687AAEF",
"E0060000E8A6BCEDDC69A5642ED27E99AA83928E15F04EC03D019695A10265A37D1016369090095274A327AD9631E6D758E79492EA40A6EB1363C71FB6912F1E1F0051E0670890A72A2E257CB5459AF8C636DE2490C8D9EF5E794E45837F2914F0DE4C5B3B3BD08D84205BFE6F5F08FE67AAD3F66E6E6C907D82AD5FA14A130EB6805731FFE0A666ADCC660F1C1001298060D6C5B98F9E2402264463BD68CEA43845F1362EB845D067A907EAD203D0C337E8021ADEB72A59DBBE3CE3F3D80F5B569FE98331D0CF42FF5123D34E3D989A809D321528C10F75CDAD334F8D97A1D34B38E7A5C74556C1A29498F816",
"E0060000E81F61185A898B6CF81159DCDD64D1D8DE89C7AD77B5E1AFE50F8FF87E57661537CAF65FE4F12BD909383C64C42928B4E3076FDD7355BADFA45E13D4CF377BB067257C5050E99D35FF37616AE73390371A3051D824CE6E185DA8F5608DF720F010F26EAA16EA02A28B2BF873ABD6BE6F87CCB813AEBD032584D1E0D0222793DB3B920AF06BD4D3043A34A7D34859C11356B563FB9CE1A450D5EEAD1FE8C9CAE1DAEDDDA936581AAEB91460409D2CA1427D26E1721675F0B0AA162C1B39F69DB78F4D1C3711A5D522D81E0660138B16F015ED38D1EBDDBB128C63C8713BCD864850FB96553252F29BC7",
"E0060000E821387C6E4AB1C0BE2EB82A39F1A1F9FE29DA276CCD4CE0F6796DD1E76CFD362FD8FA0E41C0BC7364E758D4575AF3730F73CAAD7160D50410F40430B635366741F1F4AD87D303F3DEF66A779E7C144E68121F03FDB20B8CB74F6068BB7350A3638565A17E8C908B8606D20B2F693DFBE0257C2F2DFEE6D844828D179CC180C661F7BF9E08E0C646B5EDAA0D7ECE9A1ED10DAB5776ECD3E7CED2D25D94D83D56FC2545143988EBA6D0354E3C2C7FEB1938CBD4C6138CDAD5E93719A67C2566EFE289082853E9DEDFFA07E32358B73321B8C8741C008C75ACDFD945AC4DC7CB13C07860D1DC0B8A9B03",
"E0060000E8475A0AFD92DE6DE89D02942665135EE5467F31B58427268B05BB503776C089ED543627F4AFD25530EFEF70E67FC733C7436778D30085BB474264764587EFB198269AE06EC6D9E11BE894E62C50375D39F5377AE973207871344C730A0D417AB804BB13322EFEA04E610D17BC375C8B57C93A83DC5057419220805DD2F933571B3A8C7CABAC3B9A697079DBDAA992AC0428D219648D634901710D68CE15493CDBCC4EA75D7F9647FE3115443A959782A2548FAC0722D2324C3E3F37C3A491BC630218278C8EAE376387446C54D93DC36A3C030CC3A24A90509D965849640549E7F0A88E28151B4BEC",
"E0060000E8060A3D7ECA63B37AF0B0DE474946DBA8279B06A855D5E225C59C6A2DB1D7044436E3DE0055095C9C1E5FE527D9E3DF8FBFFDE2781060E29BB877931D90445DE40FC232B842E27DA55A0A75B5E2CF6ECCB801118E9F15E7FBE46E6D6CC79616A2EF8A200C0E8680139B47156375A527D0ABD93AC03814431619FB78D13FDC6EAA684B87026EEFF4691256DC0598A1D21117CAA72BBCA267F1A101D2DE63BF693493544771BE16CA8FBEFEE1EED7BBF015608D07523C75AB7B27E9E7F70F2558251712C767C49B4F6365EC3180AA61D1231B2C8FC07B1CBCDB10219D321E73827D9265AFBAF00172DE",
"E0060000E863970DC9375139F244F57F1D20075DE07945025FC6CDE8C435F5D68D4C956F45D0C9F627A733E0728EC7DC655B25445BDC28949FAFAB2046E8CA26EE5E869E06953157A8FFA0A6D15C78A52E7666E9C4C150F6B3F7819111FDD6E5A7C63E6E06AEE40BA19E9C2E192A1CE3475D8E416F326D008B0283D9FE5DA52ACEE0D801498962910DFC634D18A74003C77B9258B0797DC53C9E86366FFE8C71095284F66B821F4B12E236F251DC8B0FA0F36522F637C399823ABC4CF4097593C1D963E4E145285C5F68052D84161D5EC2A8FAED5AEF2366CC26E157126BCA48B6D9926011622D4E61AC66683E",
"E0060000E8C551F21BFB453904399A5023A319C13EE606FC2D841235BA102E50CC8DB1D292EAC7CEA75E9BB784360FB1649210589FFF89C0782BDF0337F266C0405FA71C3761B97A635A2AAAD0B49620B2D4964BB358B4DE60A28BD1A23587C866ABB1DE6C1198EFA65644D63C23A4FF0B9649F774E4BA020294D18CBCE0AA37CC362C2C012558B9B809C6884432B71890A48D6FEA3C2CA7FEC9650E445183486D7C87875FE344012F71BB971F9ADCA2D02BA28792F2DD10048DEF9DF635AF4EEDB23F78A1DAF69E32CA2F19CFCF5B25ED7CFA085E5E99B703007124DD1F4BEA61B4DE8E0E649686C081983E33",
"E00600001811C0976C7664DEF2378F1DA7D71BF4ECFA0CC34A28BA9ECE",
"E007000000",
"E00800000889B2ED61B0936982",
"E0050000089DCD7F5F05B9D62D",
"E0060000E8E55A639982F4565E27767548883F497B155ADD7635DD369F6CBAE3C555CB2E5F35FAFE2322505B803FCADA070DA34C6FE96C2616F4B12C7ECBFEE33DBDB66CC5D84386491A24AC42CB1E1B9610C5A888FC1776108191212394310A48F175DA94C04FD996C8D80D1F32F7AC1A15E7168A6AA8458AAE38CC24BAC6A0150158171FF6AC30A407C21A8113504FDF6F9F1DF87DF6F25D024D02AB870CF0058389980DFE0A195CD6A563F92625D8044BDEC8032C53AA0696B733F6CE7D4962855EC1D4B07F080C1224CE75855E5B36B22CDF65249E51B69EF873855698A0B28281DD601101EFE226554B75",
"E0060000E85EAFD266B1A8492D14A298F8654B190D9835C4973F2E19045D12AAD5392380552E4953D0F20EF78008FC48E0454567D2651DEB9B7F7416368ED0918F08D00F1EE75C7386BED85DF0E8BCA7565F827F244A615DE2EE0B08FC1DE22C563E1F090DDBEFA2484F2FD575CDCCAB50895E474556B62A848838F5629F91B4BA94294F67A0B84F3C7CDFF03DF39EDC0B7A3C5867AF0E6F13F247198FB4BFB28E19CDE3E865F981627F60FFC55B3A0ED4ABF9B01DA8877DC7B28DDF85DD6143B9F68556AE686D7934D7D81AA3E36D1991990B1F85D4A7BC8311E182A60182865F39B35A9A962BC1F9F18F52EF",
"E0060000E8C1283141E21CBC729425D2723D9D21889172A61558F9C7B93721CA011F9869989BCB93D4F70BB8F03B7B4ADF4B3D26E95759465A0512C549AE4A5249C36D0FA34E95D2C4CBCD7928E9460E0B8DC1FC16556CD374EB597585928C8085AE43AFC8A3D55AAB8B5613523A741CD211F3885649A9D5446B833B34B299C7FE46C653C9A1DA194D28321484C32817B088ACD839F9DBACD90F1EE735BD36C6530C2EC26D18A22B44FF67958DD21D2EBC0BF2E6DAD9E3CB02D53FA85CD654804222837DCA69CD362CE7047506B0B6EF85A2A4E045B7A62383124F091DCE7B520605B1437DDDE1961CA7276C93",
"E0060000E8F47AB665155A38C505D951DECD0857AC33F993E8BC5DAE05482F5C9461749EBC0334D260DDD89E50C183303D0B920AE9D6EA8D426139F07E510623A54CD6E3375F5D61D9A73AEA72214AE269264EB36BE6E9D00B439797BC5396E0377B848E00C4CBFC69D92DC11273ED18200F84FCDE31871135C731A21C98C47E273ACE27DB743796A45B3026EFD8AC52AC91397C9055A0E0A53CD00676CE5F8F08B664D3B18D3D93E38E9B81E55DA61A0BAAFC0E81352EFCC41506B104BC3AB57DB2C99E7FB357335338471B10B5AE62BB1A92ED6B676B1C735283AD20A3DCECE5C7190222D36C38E4F1BF9D03",
"E0060000E84F519C864EB8BF86F4BEFD0713BF545F6B6131F1690851A284B481B64478C8E7120909A567D85D1369A43271845047150036C9B193EAA4F5924ECBC0853BA99BD03C3ECF74D6A8900CAF76FBF0CAA0658E734705F40DEC8DD9FAE92B934DE5D360671A451755CD620198B085B1A9775DD5495A39A8900DBC1807F63492EC70CBE9E6030720C896123117E93EAF4BBA614125B27280943571AF42515063DC32154D68DCE45019472BFD6547248A248730CF3BF1C667D208D57C99EF316526F67D302A5326A22EF534009DA0C37CED72A4579EB53EC498B6E807FA4F8111F3F10600CD1976342DB6F0",
"E0060000E8E07DAC7A4D433ECB3711D9ABB047A0B6751E9B066CF74265B122C3174D41FFF664E4447679184E72B5D5CA45FAAC22E0CE72F28AF954086FB97763AF8C3482CF0D16C518A3475192BFD988B9574A72E61A1EE1D7E9730320CC8146B09DB8E314A0751E72CD0AFBC89555D78B4E3BDA7319360F338380C1AE51B842ACD37CA2CE597618CF51EAB7C482B8AA285C2AC5891970729E7791305CCDDEE28230AFD29DB8F2D5078DA07B7EDB5DE7692EF48A695CEC1C92284FC5EFFD8CEC0AD26FC9B3A842B888FE21FA237BF434A7BDB2AEEA2D846F40488F6685DB0262F24BDB935354915078DB0DA4E5",
"E0060000E8BAA04709BB54E7229E92B82247DBEC04E680E4CA745087519039B88854D117171F962B18390C8BFF6AD4C7E08935A9D942772A94B1D1FACC482F0BF4360B3E7F3908D219FAFC7C976BBD24629A34424C411758EABF467C4441AF64865F905211C01242A4127D6A66A817B7990EAC1912CD4B69564525A1651F61DF2B7C8BED8DAC646225116DA4D06107BAD993F12A023B6EC8D42AA161CC53DA8724F761ABE73375380A1441FACFE8D0B7F85E8851800B8917507F88AB0304589A48917C5EEF178A566B48A64B28C08A302BBBC036C25221898626282FBF31E4D8F6C54CADF18FA32FA3D2D11492",
"E0060000E80397908E41B8F3F8DCCE93B2D6D9B68D11100963A283FCA2B5E591BCBE3B189BF49A9CD257E6EB5911541E1D19552AD1B55646A8BA0E94BEA0919D5033A5A488012C80B5F8BBB55D3DC810924265758F735C447E0E2C4ADFFD891BA15F656D0F6D6273B4663175A618F07AC1387A682F783D4C354111E25A3577E4536767DF01755A3A0AF086A0E32A76C588DC1DD7B37B767C8D675A4F565E49F459541EDDFC64227E19DA6572CA23DB02F49EF7DF8388A93BBCDB1BCF70186CDD5A229AAEAC503E3D04E29991B3E9A5BE6667EF2AF99B254B727B479C69D0D87317EE0D7BF253EC61A3B82A51DA",
"E0060000E8ED78F57FC72231909A5998A4BA299D1D4BB4E789783A4F394914CBB73BFBEE6A20C1AA3DB9008A7C708C96087C806B430FF0C2B76F3B6C31B5F53DA2A63F1735557A96CDBDA51ADF8FDD6691535EAC690B4D3E1706BEBD1460EF94B52C2BD1615E6A9CB2EAFB18594A8978B3DDE91B23CC284B05E33B493B9AD7BBC608748FF943EE5137B53C2CB74E82BC005E7A9D3D27AB759EF4C8B9F1F1C36355AA800BD88A38CF65580C39EE2B88978671B599DB8A18A5E826F824020BA8EC8D8D893BD1776BA52598D86A06F05C9EED17FC311B0BF6757AB48FC4DEE6C53C70BAEE16AE096FA25D447CEA77",
"E0060000E8D57D314CA2DBB3E29CE218D0595640E658628266400685B6AF91DBA55E9ABF7B56AC91E51EB23B83F37C7E6CBE6AF0346C7B18A77AC4827FCEF06452BB26966F5AB01BEF7D8B0C5E9F4127D6FB74EBD89FA75C076A8C4CDE437698929E834A28613A37C4A621EAF57080D846EF8DA2A0328EB50A86D680583931F863A6AE0B210A968CD892228F5C95D7DEF1E600AF0B25311871CB83D625F38D4AA09B7C56BBC8F13AD73B0D8506B97829B025E5930404CE680D1B22F669648DA7A7C8055E7037B983E8ED7CB60A9AD2248158FF84B1800119FF0982C81D71C23EACF91960769581CE2B23F27C90",
"E0060000E88623760476BF09BCBE1C878559104E87CD39EFF824E31E0C400FA7EAB3ECAA61D9C80E3F72FCEF15D481DD9B47652F37A20A820ABA33BC47A603B33B28A93A02B38315CD0FDF496340225CE3D7F5643B081FAC5832D53DF16CF5D9C9443022F0E5960913A713447DCAEED171AA034202999D931DAD91F5B767C495362F2E2C2C21BD74EFAFE7A9E1C0E570A2428934C6AA32021BDF6D82C3CAD3DBA01A1B7E405BD235E8D7B02EDB0D8BE05F0232C9A157F9B13752901CBE4E8353AEE9B3FBD3A8EB1B61EA82AC0E7DDF6557D0834E6336CB8CF21C5B7F3EACE37A84629FFF39BD0FECAECDB4DC61",
"E0060000E81AEADF26B9840B4A5CDDDE33DEF46AD09C9542886EE2D82CA52654315410AF5A2FD2C11E83A4A9B8E543E120E0C47AF2DCB7E0B7A9762D5CCDF17607F0B0D5438FFF05DAD25AE87C4FBC782BA98DBF305B7F280E67902EB70E3DC17DC440ABB0C6F6F398EE20A316398EB2FF4B6001FED4CC5E27ACDC050562EDF94F47D5F77EBB39CB92062083659A29A3DADC7FC44D476AF752D972ECDE2D531FC40954AE8A26FEC2F59A2D3829B7DEA18D9B0E4D17AF7B108DFFC61C2524268DD7DAA969D1C50055EC7905CA17DAE9A0464347CDACFEE17DAFF6A9B9CA996B178D033CCEC89069A2A20258C303",
"E0060000E8E36A9D3EBEF91F42B17603AF42CB6CF68CB203114D48AAEBF4548F75E658E19101CF4C5577B149375B496E3E51993EFC399FE359F6E875B2CC68512252EAA4DAFBDA54841BA6C34C98A50C2BF53015A19D3729CD341166C85A5ACCA902E2D446257D6161EE888AD7D8FC92741F7088E04E41E5D5D9F4015EC8CD095AE24F754B4CC6FEED63DD97492988DE67F466BC48E5486D861943A0EB25EC575B4AA0EAA9624C8D9751C8EBE806A9F25AEE787F7F802635C4B9CB5C370D5528F7F9D5D13601A60DA0BBBD1AF2B4A5CF85E95481AAF0E77605920AD9626167F6EB7A7C85D43F72B6620E27E692",
"E0060000E8592BB9EF7A17297091F7CFC2F76E2D8C79B11E431BA28182038FFD4FBD1AEFDDB5875145ADF45F1A44BFA9E1C0CFBE6F7688EE46F49BB2A205F5813ABCC0135312748282DEA33FAEE530AB957B88AB82D9806F2978D57D506A681B01D03AF99A6B29834CC4452821314535A9EA203F108542B6D8F9B5338A011DF4713A3DDD85EDAE85ECB6E67F995BDCB2D390CFFF24D1E01D69B03AEE196C1279948A7A36AF304CC9ECF449EAE973EA005486C326CD52C7B44B7B8A36B742F86980E069988CEAB4875E880EEED9FDBF920408FFD43CC42F7E3D2DC4C2C404C1D1C214CC1ACD33DD77F6C86C3409",
"E0060000E84F3AA5DBF1BE211B0D63E454AE6DE790F19405019AB1D841B69C795D0155626AE345FF7857FD207773683AC7E9C87455F150BB9F2CD4138CC88551BC6E1356C5D43AC1F2440F2FCDEF6F17D1D54E764C81368228E56E565B9D66BF7C10FED9779659352F1ED71B1289CCAF584B79E127F6E381840C713E9E6A9E4C3EC9AE4C4485BB1881C4B3A395DBBE726ADFD7EDA662E31B77482A5FF2219D8724988C3E49AF47F0C0E5D66E18FFE277EB3D90D0FA67A4483ED8EC55C11E280A00789810DAF8998A5688EB103A3BAFD7F53BC7A489356A784B1344A63A0AF99A791DBCB1CFECF906A645A97A1E",
"E0060000E8A06EB74FF23A53F7592717A2A80546064A1B77A8E11EBB4D49B7194E70F3DACF4D58AACC1F2CCE12FE5599ACF67E0A5097F95C453997DAF63A40F2DD4E7E099DB629BA8F74CCEF7093ED2628FB4E359611EA837BFFF00C6CE3623D282B37E65F43AD56A65DFE70BBE5C91686D07BB3217FF8B28A1E0F06E30409098768029696432D201946EBF65528F4E9D98191C0AF2D7746AAFD015A867A204534555579868A4FF67C14B66D9EEC149E51D5F005EECB849B011617A9AAD62F2F714D72F84ECAA9E8AA0C4A5249852CECB8EF6299BCAC09BE4C116D7D54D0C6D4F1E5878D207B9554EA0E2C6C15",
"E0060000E86ED0CF5E99703FC5E398D394EE3BA054F252D3291D2E2D5A8E9D88EB5125516B8B546E2706C46706330794B5D1CDD66432173F3ED9EC7CA3DFA9E858D13EC218B8B9CDBFAEF926DE45DA4022309B934CBE273FE941BDFFFDEE062F0894FA7305569DEC21D5D2F57F59D88134DE60FE1C60FAAC1BF2057682BA352E64BB9DDD17D2A3AFEA0EE9CAB3CE090BA712E0E966FF378FA90A5D8CD9F7F6528D9533917DF8632896BA3A99F105C17F7E6854EA58A2AF3983650875A0C978E74272B73B7B95FB4388359FA5E3C0B37FE1EB850AD4AE2EC7112C0214C7CC817E0AF60717FAB5ECEE2AFA0717B3",
"E0060000E81AB4F1EECDDECE396B8BDBB1C60305383C4FFB371A368B6D9369C7090CACA59667C139DE5EE856BFA03B1302915E890D7CD6B6F6E5405FC1785AE5CDC21AF45F9619D4307E8DADBFE66B21A5FC0B6F45213A632F474DF176ED2E03B8384D8CCE15BEC5487F29781AF315E010714A484D7D47EF3B5D77FD0CABCDA84D6842727336C0E5A6EBA208C04145D816D8633F476AA881E791065A26EFD20466537032F99FC1AB940DC02FC1D0B6560CB33194316E2AB47DD7201071A32C4A6C5194839A36D05E7631C679EA11BB2E0A6BBE56336892C0C3FE59FC0F54CC4D8677325AEDAA8E3A47907743B0",
"E0060000E8B37D2509F7428384EE8E4AC41E027F4C6933B245DB98F3CBE47DD79DF937648A39E14B46B412C1B81B264994E3F687215CE5D691B19DE9DEE389F7C4E9585603E5B451AA078B2B6F8396D529606EB7953A2390A8E478DA9910E9063F60AC3B67F85C9A3D5135761B8F8EA84DE495E2CEA2A3E22B0031980D1337B61346FCC7B26E0B9C2AE4F57029A0DF370F5A44781C5B40138F7569AA322CD4DCA68691860FE796E1162FCD17FB47B689EF0FE255B0E6AE9EED7B0953343D484F0431154DD9851B1BC48263C00C4371077B2A8691DBDCB101F2667BDADEC957D10067BC04C881D263882904426B",
"E0060000E82A504A151FB874E48B81ED20F1E407C5616341B81AFFF58FC8D8F3B295F4A9E1E147165C60EB6DB76A24387DE7F8AB8FA37FD4296D46D44170FB94DC9A924BCD8D13B5AB376F0D4026B734ED2A16DDE3FB285DAD109B24674D677BDE1F45701127FD59E50032A158F6F384A3C93A6A776832ED25F437345CB1AB9823AB0DB8E0F022B1A678021B133564D8643CD11A37E02E58AF65779A6EF1BBC43C13E5BA3BF6DA797F51DF2812DFD5443233103354CA9C431635A9CCE3FF38D83C41F7EC427E92C2C17A07C7734F154DB536AD6C278A248ABD6189DA75A4E930E63982B8B45F7FB5B0880129C4",
"E0060000E8EF95C987E0AA019681D07041928EB8B137628A8F8FCE6D9309C3093DBD1CBE6305CC142CB868AABE791CB4DBB9FDD5D7C26AA65D3BB531C45E8CE27B8F5609240946B34FC00C334D48280B9DE7036C6168C7D404BD8EB449893F73325FB1F1299B769609C3483C16330C8656487B5A68823D9578446BAD95C2DC00484DA9682C05E8AEBEAC94B5C8557D9ECFBDECDFD1AE89CBC9A2C5D8A18CEBF9D4A8AFFCEA1052AC501811BB1A8AE8B1AA55EC397172CB864E1AC33A758D5FD733F72566EA1F2838D26120D1BCA014B60D5021D3734B5983865BBAD7D4D870331371960C8A34F6B0D8CD8EA9A5",
"E0060000E87490081B35D83777F9AB6804E9FD2180AB0168B13782844922695C704AD23CD9AA3108AA1FCFFE00567427D3FB560A0AF31D6DB016368AC83EAD1B3BEC842ABE5FCFB4BD31463DE71486BE938364155B6D61F8F62A612081C6CB2F00905D2DA938E95980EF81B764A191B1CE04C760A503BDC1C27C7BCFBCA22B1B090AB06BFFBCB8CB09BC4910E169C79615C9D92EBFCA6A997A1EADF73B2E3BE1115A8235B50081C38198E90934F0B520B90B73ACC447F5885FAFF2D65FDD2E7D8A0C2DBFDF78F526FB660AE6FB150DC7C7875C4523F20B1ECB0B26C7970D8117CB159B371074C387E77D9F64F4",
"E0060000E829DFB0FB5BB8E9FC43639729F5541B3D69E38CE3137ED5340AF3DAC60B095967F888C50336BB495E66F88A5F561F0A961B52510E3721F3A27A53DF56A2C04B10F4F6D51B257838470D4F9B678CC413E45DA39D876D49A7E3302ACDD3CF6848B53F803580B28A01D9E45E2C98772D921CFA451273FEEA3F8819A74564CA9FE72845A12258E6E08C057DC6696E02B748B66520F0613ECFB1CB67500966F9442673ED1A73F6A4D54447333038020A592AC3E6CB7752FA47F47BACCB899598D5D9E6C585449FAAED533573B68CE27AFCB50035B6C37D51AC60E5CCBB2F7563A29CB3A8F8FB4C86B074FC",
"E0060000E8D2D3948C2DDC87B1D48FB60C66996F80AA112B440CD43EC83A211E40F6DEC265D71C120B022F7BE0E6C659C56B0EABDC6046C51A0F5B05D27CC3BDE335DD567810E2E9D0134ACF2B9473D3BB6FE6A85C1D3C34C11BD6780031E393F5B4C048ADC2D41C72911BC50DBD5EEE4FF44714502EE9BE4730F5641D55D4D2B68931EF5D292F7602D0744FCC23D241E1936F846617A3A4F405010A722A4AEB63AE5532D3445A086B36B4AEB95D4C18A328DB0F0190A3ABCF0875E9D49944CDBB3C7C37B83FF569C80BDCC76E4E6FBA3CF99EC79DF272C02225F5125D71FCA7420436CD30363300CFF404FE3D",
"E0060000E82A31BD2B7066DC10E54A282E774C172BB923C2A0587BEDA454710B9A0C54AE0FFC5A530C42A259AEF68DC1C4BAF5913C30E4771F62104A9135F5EC44DBC6692084CAEC15E1671CC68BC4BEE090B53ED2C5EBD20AFA9EB43EC0B576248CB0942893FA8DD2000A34909C205CE23FDABBCA6F517F10762EA3AC94224972012C5D1173EC3C0559815F685462E28A5BB7681496B433F3AFB5E99EB0DB835384495AC8053CDDC6DF924B3A3ACE27662F3B5BF958A0DCC5BFCCFEFF4C52F94C3F0CC39719777525B7BBBCA2AE5CC4562279E49E4B2AE6BE3BEC289DB1C461E702AD0D31FF455C9B620EB98F",
"E0060000E886280F06FCDF250E1280FA9476799634C3F1AEAD0E025226B65627DAB28DC6822229CCC602E146EC5093859679FDA9E7D367408FF1FF4CCA9D12DD379108044FE0819F767436C781C8647848FC17CD7F95F00CFB46E5767D492FABFE7B067E03479AE55B18F358FA82901660FB8127F9A944B160CF4FA36EA80B859025B9DE6AF13AB9112E17910F15F5CDE7842797EF16D8A42BADCDAD038E4A8A3A964B5CDAF607C535FC2258026EED58167EB6E4806F6FC7DA7F5DCDCD6080CFF6512572143DE992B39C3E3E6D4103DEB429CA4BD4702B6B7DFF95E901DC8079094023F7ED51BE2207469895B5",
"E0060000E87EEBC987554FA0F85C5F57B87BFBA01FE7E16FF5A02BFFAEAF577E7B6B9014CB1D334F77DB95F88CFF56B14FDC1E7BC7AF9D5290C8F9CB44C23041D32017AD127AD46DCEFC9BA7D99F75B046C20D68B366176F0860E9035965A448D6EFD9C3EE0D12684C83F60FE946569B157EA6A52CA80463ABF2C85995D1C3E1B13841C5A03C29E3B426BBA29FBB457BAC659CA1259E8D44DE375CF85377B424A35D6900D49E2E5310641EA08612EFA439CC5E8F6743ABE0242471A9F9905946E076BEE46DD19AD524C4AD0F9E92BA87B095B36EAC708A9B2FB03B8918D5B865F74823C1913794FF90E32540B8",
"E0060000E81F3A23F03B7D2C652311D03E1B59DFA485431949B22F56F33922E1EE4E32706BE14D5DC4BFC47A187C1DCC825A2500B81B6BA3C6FA7FCED73D6D712191943A2CC0B3E657EB22C815AF598E9139225F32B73DAE5A3A64F19BA5CE09D7DC37C10BBCD39FB4FAB8519C21B7AAC80781CE8176E32C4BE102673141875B5CFA738A9F996D71FC18ACFF2EF8095F644E6953EF6EBE074EF0D3928B70FEA3668096781556AC4982B35319A553914A4B049053B8F0A77E2AF1F434C10AD7D59D6CB89FF4A39FD8742DAA9D21AF97B2EBEF8D760F60838A1A706A228AEAF8748A7822EE6CA7AB07FFCED8C58D",
"E0060000E86EFB2C345D379AA6A5AF985B53ED9FB83B378556F3EA813408C1EF35562833477575451219D7442375E8D17210C85E31F6BF3FEB0E38D97858B6C4471D325E57A5A2F0B45011D2419F3197B5860472DE48DAA2799628C26B2D718B9F83BDA6B550523CCB443B83AC98B37CC5343DFBE682D415325E8A61617C3DC1EDBA673031B896B51D09FED3F4B94B9C120C023B6C62B313C318D682F69CF3FA1A9C282DC10C1FB41D60FA84C8150E31EBB8504115A30B4C245571B1B353B13E558B2D1311BD934CAE116FBBC3F4BB2C5B48A870CBDBDF2396B51ECF66B1A96C2EB87449AA2C65A2051B49F1BB",
"E0060000E8FBCAC30ED13C0292D13C5138BE3AC32DA151F799B7E2EB3C43643EDFAF04DCA380C49EC3398AF9B4BD891101894E622A72A7A4268880B83AF1E99AB383FEBD9BAA3EB9355C75E765F2AE72C8790F3E96EAEB2A88852AF7A6A801FA6A057470096743D886C74BAE37C1AB40319F3F244FC7DC505585A4582271B032B13F71CF062C7878329D11D02B99723343FC9632731734E04FA2A2AA2426539489E6B8E48425F039A4DE645C667B07D377CA56634EAB26D7C7F6AFAF10F26236E5137113319471BB5EADCBCAB73C38B5B888B72666E5FC48C556F153239423845CC3A75F660E57B232AFDA79D7",
"E0060000E8293FAB8E40DC6109A41AA36930F963D33C7FD71C6CE396A3B520DB3DC905315E38D3F8A8D474E4F62E56F4AD865BEE11BBB0B07CD8DC0A9F0CF32F4DEDA919814EA63C2588BA3E9E8CAA4E0D4B1E45FD14F5F5E74CA3515331B0954F9F4F379032D7195F6AA16916E6595B92932376FDF5B3D561D6CE6847F01A21C83C2F42A7F971CAD46CCB96E3A2078447757E594B738D7E8BC93F36F58AA415221514153D36C6515BCFDBDE0A1E26D946316AE8A70015798557E345E7A7E343E8F4A44F4837D7CD2E0475C060CDD111D061298F6658BAD4C558B3EC64B0DA869C04DE09B442233E02A4EAB499",
"E0060000E825F2BF2390D7C10CBE225BDBDABE000FD5B22F8712BB4690D22F8E3C80759E1A19A2339AF89F33BB44DCFA2913F35B714306F43C7312D18A46B31EA001AF7CADEB933EAC374051F24DEE4615F55FDD80F0EC80B6FC85F2667A2C2263FE67CB0F5796D13FE2D047782EA885F249475F9A4AF3A62FDD251E41FB9862F39E1C5F837136DC30EFBBF8DE381B71CC22F8E261CBBD03055DEAF4781EF4F930B716BFF22F9DE026A5BAED72392A6781AB5C78BFC075009B01A7610E3EB18B4B15A5504B490B6EB3ED6AF98C23BDAC4ABFE6B1B783F86B34880700E370A8968959906C370A72105316071041",
"E0060000E814D6F84C37D80A1ECC6F34325437601182E64A2510A371592B0F2C37246245830EBDC01ED1120F7B01102D9F87B2D43211EFF3E866BBEA45F20228A3571A5579017685386D8372F99A8DD0B842C098FCD70E870580CB4EB27BAF8239DB745A0A3879C78C43F9CCFCD1A594F778EFD9B695AAA5A780933CA1C4A9BB59ED3F420525A5077B6AB8F3566F0E11E421FB1EFBEC71A348A7D5A795B5BB7744CB41665E38D1708638C6DBD8CBE7238D84C7A6807E58F07B8E99C59ADBB866398335DC06984A21C76B05B12D492AB2E31B8FD2E632AF22B5BE3EBEF311976F3D23D5F04DE913CF24B62EDD8D",
"E0060000E8E87C6198A4A61BC4DAB3648826FFC963F6A821D6A4176B04573C67292A8030A5DF0A91151A8CE089EB01CB81FC980B4AE48FEDF6A011AC4BE4DF8BAC876126D64305ED745A2A3891ACB1E6602F76856875CD7ECAA7E1225E0010883F46DC446018FFDF3DD67B440CC309B06EAC0C76061913477C82DCB907640089801F37190BEEF716063A833845587B7FDA31117DD0C2181D02155F972CE32B1B17B805C8BD3584EAD0C71619B9F1D5EA9713CE14F039D8ABCA2AEF2267466D12577CE21C2E781CA7C364AC4565CD3B73BEF259651FB74FFC1556FC5D3FCA82CB88089A742CE3059B91161E68D2",
"E0060000E8E37B591F4773E5ED8E9FF058928EAD08C30ABA1749A4E0441E4EB23EB7AA9A8D7BE6F80C56AE95F678231F4C69A98A321AAE7E2D9109310783533A507C1EDA994644B8C101CE15626BBF4898EDA474CA67DBF484DA6A3329F3DEE8FCCF9E4C6C200629A6D95CA06FA2F19954B4BB9D2AAAE79D4DDD4885C0D567C6302A8691E693D1A986EAEEBA51AB8BDEECF31964556B3FD3BE61F7BC4AC1D87065E0E23619B8FBDC91D97A64AFB7A870B1A852F58E7B8B0D5E8CB86E4B01F37C5E0D8D4ADE0D3BFA9823BF4D383C58AE8D8ACE83D62F9A40F59BEC22EC8068EAF9B62740DBA66DF6CFF42E8169",
"E0060000E86080D8A4232A1D093A3AE0C90970E5B6817D01C91E198FF897422446D92459E0A8B3A3D0961F1F5CA08AF7214939BFE140768D777A69B11A4449446B0494B18B0C8FADD85009A03754D2B6A1E3A1E7C67CD59CD2E7134369F9C1637D5B78AF9787A543C09153B2E627590FB514D1448B6CE42731EDCD2D39B82096708E08ECFE5793F2DD9B3B46B620FA7AC48F15E1CEAE87C3B86745FB57B641F0696087FA2CD68BACDD600E64738FFC7D7C17CD0157FD76A186549E6A1F8B91768BA3AC1375CD2F49081974992926AD7C31A79D0AB0A74B08AA422B38ABD30DA6BD0C215BF624CEA6BD27D1C943",
"E0060000E8E26C5C9736FDEC961A0FFC4BC0C0F18A74C5D746DFF34B2E3612A5825BF7488FAD2377B88ED945AD869084665A775A4B70EFF9E200F96DB34FF74AD7FC914FB0442856FC26CE01C79F8337906B79096132455E5C643CBB3D575B6FFBFB14B54BF40DA0AF91C1DFDF8F2BF0CF0717EA0AF3C1BC0860341EEF2B001C0311D5042F0FFD5A75D88AA6FB5E0A04BF19AFB1AD22E73D1DA56A83572C0472468376D53651E72A5D423B881F4E1679999A1777D121F959B920BC402D749DBA45FBEB1C06818C5B68F2EEC1B8B2E8EC3D0758E7534C36E53F4DE3435DA2A17C3A0EF9FF99122D41015B1AA78B",
"E0060000E81152D6B67D3250FD85789E65408B502FC078F392119DF0499C92214378D0FE510321E711757EFB6A9EED98295757C13FDD2581CCD6DC1A9F1A4E6EF0C50DFE4CBE81573B41DA68C6ED7E340A185D15A35992638DF80CECE05584006B19E8221B40F6A79A9B9121B7EF516912F874FDE6D15C362BA5F2E591D32BD1DBBE6E8FE70D1FAC8B78FC08D2BB905D83E8A54155B3977B4F750159CF2E707A4EB72838AAD1D1F4126F38435B079DF7DB4BB0414E1BA0BCA9F5DC02B6A9A0D5F67CC31CD27B0BA7CEFF2542C2A8664E70E287E91D7FDF1094F9B2212977A70172A769C3C7031A364B4939C650",
"E0060000E8EE292639B4CA9E9E39AE9F9D38CC38D8C800D97F413A4E946CAEB3B47061DBB96259072B10DE143BAE5DC3FF8F2425DFDB8ED77D70C7AAEED877C532B67D9170F19ED76D66F1EBA3D040AC43BF4C90C489D352D1AA37CBFD1D9F7ED74B7BD4E2F207C09AAD2008BBC4AE819EFF2C774F39BEC21CECD6B6E495F7E0F3716283DC8D6A7D8D86DC37CBD9CE17F824695273D4D0BE0BA00390F8E003CBF61E156678BCEFA3AE8FC978EA36C4B2A9115027849B1E4BFD065C8F49B28ACAF709FF49C681F99B7769589434F62973E0FAA9E97F5656C613C61CF158777BE9907E6E2260C0BCD7ACD6DE6FD5",
"E0060000E8FA327752FA89AE58F5119310263F0CC70232B22DE8AD15786A10A89B076BD3AD54468CCCCB15563926B8D5382601FB86F82B7939CE3E51F243EC840BDB216318041085AE4D7FD2A08D88D0F13659835353479427E499F24F651DBF11377775BECC389EF231A610B3953D8745CE1DA3F60ED914011E3F6ABEF0B8284E06B374F8BE2C6A6DA79FDF2765CDA924686B1A43AF35D8C0501D3701DEE2C6391E204D95F154ACC813657C3A3EF8AA60CBADB6053006370A905B371F81C8304D3B761C97CB18A285B7F0FDB3A19747ED0F257782855D87EED8696C0B54B6109313AC2C147FA38D0EF6B42F67",
"E0060000E8F30182EF3A9F549F8BF4A5B6F7BE3AA123C48C974936571C5996465F8EE0AE27DB982C8C1B6C9C4767537BF55BD1CE3DBF2736BA3B281D5657A9CBBCEC098F517EA0EA58F48FF69B4E9127B5E0BFFB2D566C07A6D3A6D9420144013229ADAB86CC36801064F5669126B129851AB433DDC7E367C1235582203579E1C1DC78C089487B941263AF70DDAE84FEC3472207E1D7A250C450FD15F1CB9F9E5A86DAF2982916C5F5B811CEE401CB6FB26B74DA807A298498F71C3337178373866B082A9311A9744E5CC5AEF4C6A12B414C793150BAED1F3617AD64D71206E0180D4271C5B56F5E118C97B513",
"E0060000E896CDF8E72C9A0C56507E3D1E5798919C00AC40EB1BFBAB2F164A2510B41A3262C90357CBB96616210D05B78857F6ECCF77FC82B86E7C250E94459D81F62D4EBF98883DB3032B9C12BE0522BFC591E53D361F8C8D5F1AAF7309E80FACE4BF971D06A7EA14BAD5A233815F1758FD764AF4D5498657EFFA32C5D8BE5DB3360DCC44B3F3B8AC1C0768C991E7CA634E97C41FC177648558BCD27CBF15B341B1E29ADB5143CD00B917896ECE041D3112725F3B7761B7551F6E9646666A78819AA9F6DA168D7CA7CA2D1DEFEF35275B6E2E475BA64DC0747070795CF519E6AB372E7FC67506EEA53F1669CC",
"E0060000E8927DB4DEB0D9DA329F142C4EDE3D0473C7C5F84818C54480ECBD71BED5D4779706D7F5F18208DB0F282F8DC82876815A3F9A7C75B2010180BA936BCC9FF86A449702ACD727D06CAAEF4B224C206CAC65D0069A81EAD3B7EE1DA98A036CE360F6EAF19CEE8C7FFF41E6AFCE76EDDAAC6A787D6FF2DC4DCC599775DF930F37D066C97033C6986EC1AE3ED2AC411FEFC2E087FB05456231DEFADA5D74303EFAD5CB5572106E5DB49449B42D156485CD25641EAF2CA4643DE12B498F0D2843BEA0F3BB5727DDCBB22851E3EAB683918CE78E713B2CBEAF9802780573444266882A60D6E987049A5D4493",
"E0060000E850531CDDB4F5A4703A428E24C4B1073CAB3F21ADA23C1BEC6E5EC94E21F8180B9B40B0312B42A6EC1A229721F6B5E844CE502FB57E777A3857F777D3342107B788DD25617BEDD80708F936C42E4463729FF16889ED3380BA0A3AFEBB22F8AF7B038DDDF171081CBECCFE91FEBD1C62315D43BE248EDA8CE633C3AFD45CA896E7540800D4FFE3A5D689E8068D410E9985F998F171A6A2B3A13BF6CDC97E022183B41C41C738A74ABFB93ED7FAF5FA0B00F389BBD1E2B7F09F7AD58E4A280CB7261E2509F487B04A886E1A8D239EEAD43C406A4F64560CF61F64AA65F02545458BDA294CB949E34C4E",
"E0060000E89037FCBC08CFFE7E87C8CA46F2B1622EA6A02F19991E0DD25A81670DFF7861B4DC29A319C064F443499F7BE549776D511553DA7B861DC9FAEA5EAC02A2B347618C57CB1F9DF14889D8EBE526FD2FAB4CEBF75C84E968EB7F1F9B84791E19A0B2B56A72299A89DDD0FE16877BA8FC4A93BE8BC0ECEB8020FCFD334161DA07F673AF786CA819DCDF6A9312AE79B54CACFFD8F04C452C0DBF5848B3D5EB0D509E9B77D233DD08E04F3D11B943FEEF7B9E8C5C3BC4AAF336E45C045756E404D4AC3C7C5740C017A039ED833C177769724199ED30098F44885067CE0647C4AB0CE04022E346F6FD01D6D0",
"E0060000E838EBD569834CB5EC80DDC6F024E075AE494715BFB0B26A4DE4B6F06469AAC2C467C5313924434013BEEF98B1311E94579FE9C52090441564C5A74A1458C7E5A795C2410FE52B91E7A8B51141A9A9EF0EE446E1329013B96D460F3CE388BC8B5D5C3B6184E61F8393062C0ABB306CE421A82E88701C44B7C2F70BFFF97E85488F7317026CD38410ECF268CDE69037D846783E1EC688F97A6EF597FAF4A408ADE1050F617CD213A35BC32EC990A2EFD7AA1DCC6D8D371FFBB329489E633F35E0B83DAFB4A622E445AD81E98CC3BD97C17E16A465B1912B868CE06574C053177F506E451AEFA48D4E32",
"E0060000E8632AA13C6A3F29AA119E6F993498F3D445B8C3BD3309B840F44A1A45093D6D464C9755A45E3C8F9E95687F8A4717A73702547C812E6B83C2947C324A937E86CC5B7AF6BF5353DB5D800240D94BDE7B86639F7F69082F47E695469E8322F06F142F1F305E6B0A80A368F2C70A20F6519D0143C8F1EB18E206CB4B2D8C66DE128DE99E44ED382BC1A282B55F1B47B3DF89266A7DB3C181201DEAB23CB1252AE9D3DF1530F25687296CA1427EEB2D3B4CF83B41800F183688874CC6898FDE32EB19A3684FD8EA3B31E96E23BCCB8BF733D2FF1C58784FCD57DE52D1FC3D27462E7E68A113C15A8B5F8F",
"E0060000E8CE0A66818ECB259183BCB849ABA3D8E2D2BB33F38515650FA0F0AECA9E64EBEB51F57C2FDD780EB8D79E40E25C12DDA9EEE7422F4B687A9ED2A3D088C41CF2A7D61F90C8B28322DA1FEB9A8D6F9EB4FC78A33EE261564446C5A4D816828BA5C4CB25A633E0E3D3934EC818428F996BB721FB8DE987B8617DEFAAF5AB92457A588F20B60AEFF3150387FA8808FAB7026429B59BCA4AD874950F4D12A370B9F85DC662864689CDCF0953DADE7A6BC544BE74CF11AADA73574066C9126DE7C817CC18127EEB61B2A64D32FEF719B435568145D0B7807BFC21E98CFB18222B739D4787019079A88C59E1",
"E0060000E824457E98970A88FD58D53392B18249A8A7415D76AE9E19D856DD08CEEFE938061649D7C70EDE9117DB13135851AF0FD52F87BE238CB06D591C64100CC2900FFBA343B0C88B4A2A8DD0D8D907B3C89AB2E84A733762A1D4DB5360EABCACD3D7E88BAC42B54730F686BBA83DEED8BB238BF5A3CFAFADDB23A65E07812D1F5A21610A66B40760F41E138A62F83F7C05C785E85EE5267C61BFBE7AB49BC8A1828E8A5DCA553481E0B4D0D19B03907F0215EB745EEF9CF621C156E1A57A359CBDE584A450DAF5BDF28F7CD18E9EF1C1856EDD1701CEF1AFFF2DE430D7CEED08F5D189AC8CF659589978B5",
"E0060000E85D4E20D046C27AF8538FEA678AF1E68767DF3D5EADFEC03DFEE1FC05F35A6C2C133F44C900797A5DB5326261933E7F6B2A269FB3564FECB2808B3688D75BEF2F12E68B8E6A39B875FA260138148CB52359CE51F71B48AFBEAD3B5D0B62DA9126067A48649578BA788CC5781D877D2F049D044EE49C9381348093EAED8E954F0D2C7612A4B9553CC52E04C970A16B2C63DE7139E44CCD0C420E3FBBFF00CE7AA7F87347C3F8CB3E6C35A9F7558F89780CEECFE63B8BE8108A67D43098D74963C0632B2E38850A5CF392998C06A33883726C1A350F1ADD42EE77CE818E77328781BB43B87F4A462896",
"E0060000E856FC53C33E40E48B9BC6CDEDA8C0CB4DEC4A694DFA2CA6F52549ECDFFE22FE24FD4F791BAAEC65A40814C98BDAE1E906F405FC94D1919E34A11843C1E2675E20C21D7FDBA1BD2070A29E53E05FF1F3A37D9EEC79E6F6A2EEC0CDBBD35B025D68F56E4E2B774A0C0866CC6888670E4E2AC19396B4B724C9CD5997C9A7715034CC06F4135FB66BF748A923E23D44F2A636190DDB017937E6ED49EC1E07F794DCB71667D68CA8EC6168AD01C3F4C936909BC8FFF65D7BD26FC3335914186F952D0394156D6452B68AEBB627DB4FC9CFFCC5FD7F8DC0F49FAB3C3199D071ACFE607DD226C403C89C91B6",
"E0060000E8968D702AE86E03DBEB489A952A2DE5C1BF70FFBA96F797F96B2B6FB0DCC309AB89E3E30DAD068A821D487851418189739CA78A39DD7AC4CF3B7F0985F45854F180A0634F840B970F01C16A9B5D736A18BD9F9D2021CD56E63903D923DF914E87603154FB9D4415E63F2E61727A2220A842131D6C6EBB475FF14FC27620531EB54097BD35BE7CE20801F9621BCBE8CEC2A66D661ABD7399EAC047EDD2A1B3410DE96C2F71D831F217C50F48F86E02BBAC04119F08956B38F5AF2A6C22BC2C61951168F10887AD7B8A625D419D9AEFBEB363174C0D35CFB1941A7E2AB2BB1BEFF46E4B65E0727807D8",
"E0060000E85480F149E88FD7259E285D99F8A3D340BD772908D81794E29F05A7979B3AE4FA33FD7ED2DC99C313289264A26028DF168B7826D73FB80F8C778137816E785E9793E8960940CEF1760A93DD6C07C918D7834B3374F947F29DD6B40312696FE00A10355A9FE7175388F03BE0C41F0AF30E4F0A1F6A43E7131619738F57C82E66ADC2A817C6FE372A89B725FBFF3C9EE5C4DD0DEBAB246CC3538749A7B5AA5DFE81910A5D6F0C69AD77DED1769B64407F1A5DC9DB6121430DC582EDEA0F5732BB3F5C737D7A08F37C24D237E7EDA69EC0443E07FE359BB5B619F7BA25E86FDDC80F86E8649E6396E699",
"E0060000E802DA1718268C81D52FD10FFEEA14B95351EE45F5F1B7F1C05D4B993F6BB1B6F0BE6B8655181F82B7BCFEF6445930322B9FFA8BA2BCD0C1F09B43F51D07F8283AFE2468DEA5A93F88658A904A2BD36BAAF8DC6BBB89EABC54DD6838557049162F17AAF948114BA8A74E3284868222B7AED2A39CB0541DF9072BBB930A82546D3344F17A040DABB0F6D441C7E918BE7BA452587BC6036A233B08343D6A011E46F01A61DEBAEAAB27260ACCB42D74B58A8134C9B3BE28AB5966DC02E7821B252060A6597660E69B53A53AAC0D28D251B94EB83FE0D1F033952EDA6E5B13C3C93636D150E0753A606A2B",
"E0060000E8C37D9B20B6D6DB2667FF42FB10026B44DE9957A5318CC719A4AC4CA75E18FA7FEB5653826BFBDC0F0AFAB68F6D5F3EC35E7422D01110F74D12CAF861ED4572F9AFE247725A0D061E5B093F63FC6104F6CB99B95EC7D58C91806F798870A012E31FC65261C37D0A1C77270FC46EB39C48D9D0ABD58FAF63605E004DFFE852D7E6F6B57D856EDB3C52F337567AED446FC0C4457AC0D59E3821338C3B15F280C348E015C157D300D4F3053548A1837F4A8F63317D8DC58D907211B7B9FE25ED5338FF5E96B31EDB529E6FA09B6DE1E3044FA9ACA07CCEA5E3868FC7BB1EAE8EB2B18EA2327C14BCCA8D",
"E0060000E8ADB41B52B45E41DA80334B7E1C6C204970010309312EB344D503AFAF2CBBA0709EA9139A5A0DC754F854962DCD045DFE3FAE0B76B3025671B1228DC02AED6A3A50D92B8086BC0C4862420F8C2A39A3D8231454144BDCBB16222F9F48A0F9AD6BD6F0E70E387AFCF6B49691493F49A8A96A12F255B8C353FDD8E56306A066D314D9165259777CE61B94059B119DEEA8A3233ECF899BFC90DCC4453C8765A3F3FFE0A324795D430EFF2B140030383408B399779B4D639F558992E6240E8C0139B760AAD1CD4D88598D4C53B1EAD3FD66F331A7243B4AD9336CC829EEF5D5977D4B736AF9398E201718",
"E0060000E85050B05CD7CDB310DAC5769E273E3C1382B9300DF47877F421055123DF6875E8129B7A25A4B162DCA243453092846D367066F4EA47F73CB1D16E825A7FC11D9A7C65DDA09C1DEFE8AA05AF82E5527EF2EE4C2632BA8D0578A643A937C3E4E0D2131AED2B666204A773D224F3AC3910CCCE573D56CA2EFB7AB77A6299B6DC5B502B8323A60020D8150D447952ABAB0376EA75E58762CF70C95401B80F012FE371B100149263C4AE64CFB1F2D213AE89BD110A593A14EED04665832D561B23FD4A3BEF815E0CA37ACB538AEC6967DA02665AD65ADCC2AA002769B302FAE4053E4E9A16291905261169",
"E0060000E8C118BFC146DAA1C83C171F9A8D652801CB8D45E44DE3C1C236281293B47F5F0A4B9D08FB8B54CBC1CBC5949F26EC1AEEFE29A4B98C480CD191EC0B2D32B3513E7D7DCE83E1D442C4F0DDAED538C6FCE5C2C8671814C6F35C36B57474D54A1B562C4DDAF9A6237AE7E6A42E6709F5B19C003AE7E836B48D285D1E7C01856E496651915AD40B6330C09A480228C6BFDF25BE62AFD051C5C03431E92563EC35DADBCE41DC0553B193E49F6B03EDF30903F596BA49739816D0B08C3B65B657DDF2498F10AC597AF0A2A4CC7CE05E66C51F1A4B39AD3447658754DF2F16248E4E0234EF79E0C09C56DB6C",
"E0060000E839156428A930FEBFB30BFD19A6481E370EB225F23F8DFC9F86DF770B99F4A627F9E7BAD1030D5F3B41320A552BB81AC23290D92AEE0A796953CA2B9C464C7567B27C37207470265A7099CFEC726863D256BEBF3DF4812C765B43C1960CBEBE3657BD2EA6D0047B961FC5D67FDD4C21172E94B2375B4262CFD120F43E7C781F4363E72D5F92E1E7C1172D12AE3558631A27A5B4E018550BADAF0B6EB6FF8B0FAC0A4F2FF5C928779A6925E2CB62E13487ED4C89B8F840BC91C37E524679D28A0685343DACA33C93F0C19CF45CF3838904D6FCCE405316547C03AC0D375BFB4CC06BC1107281E57AAE",
"E0060000E833D33731F0887A7215EADCD126B311A8F9E747093877609E4E5D4B709F093CC54A76C5A4A51F94C65D3572DD467FA805BFA3D31E0F225A1A6493C98183CAD634BCB1CAD9F31B9FA4A18BE01AA717E15985E906E25D3B91E1EEE4B3BDD26CCFB7DCB821BCE691E0A0440B9B2065AC0B98B58B00D4EA71E1D756C21696BAC91D161052EA7A8DE5129B4B3691EAAC5CD59C210257288EA86F1929C3084B44F2DB595BEACE28B4077DEBADF864156BD896983D9E44282C296F7BEB4876C9FF3EF63CF8D8B12DCC474039AB9248A0DDFBEADF8F54396734F8A17DA6CCEFB76A41BC8303D25F61E419BD7D",
"E0060000E8799E7F57308D5683A771D50287C611D1488CC26DB3F4CD4C9A0BE05C432B69D019DBF1E9C2CB94C757923776C2653FD15CDCFAEBE160C600BAAC8DDF8C7D30F7E26B4AB610CBCF403542A36F109E7D657D7446B26A9AA8BC5D7C9977F6B12654820F1D5CA1329A4E8B01D1BCC1F9002E0CD3A3B7DAB4B80501787DBA44AFEC05831132157C18AD3263C3DEAF7A7E19D2832A1954BDD0DD7011907F4AA9832E376C073B13952F0A86D3BFA4C653B5B57D2FC9B5E42DA9DC0DA9276CEA9A7CB15E34C9C1BC1278D569A05E9FB1AFB089898C2775409ED801CF37AA14DB2C45EB172778A37B9792D754",
"E0060000E8A36568F3DB8C0583B31A51AEB49B00B3C1DF7FB91243897CBB3A52EA005B82F0157BC9994207D29E492316D01FB8D879CF5A3C38238995334438924AAF3BB519E533808C7A7BDE59DC900BED4AC31283140353051A9452E1529E940D9129F63265B5F3C3800480E33F0E1699FFE5708EC41042E90905151557741755A010811694E4AFA76CF1F354A5D159ADCDE257BBA307FA4B15AF21EB91B0A365D440D47F839C7910AC89C2A8C6871082F1F02D7554277D6540366152EA45E1E668738E3AEFF114866ACF967D0CE4CA54B76B9322FBC380BC05376F36C0A7468D8A759CB9C01B1BB5B95E6CC4",
"E0060000E82CDC86BF5D8635B2B5EA2A428C5A1CCF7834EB2BA705126F56FDCE2DD7978EDF6424DE6F2B60AD1084C8B5565755B14316058E3AEAF5BFDFEFA89D1DBD38FE9D7A0D37FDA445090116BEA4A365336B8402BC728AB0940B62193FE912D3170CAB8C0DB4255211A419C254E9CAC1CC7E6321440D4400ADD1357B6D75EA50D7E73B87C393124EE0FAD194E1E19D7F4804749C2DD3CF99883A91350212005E7F0900BF13F4CC6DD60562F6958FF570B91ED07D9D7C134A70EDA0F9EDC9D357CA6480943659F2EFD5F35C766DE080B45C14CA5A20F09606F3F6BD374DA3930B17841B46AB4CD4F439A6F1",
"E0060000E890A0C241F7EB1CD42C776409468B0DD90D74AF44DEDADB1E4C516D780D39439D4DB8B0C48DC9AF3925E57B08E196EB44105F3E0B07BCC070F3CEAD158B85591902884B6E3F7335A3F1455BF7985AF697CF7E814DE87032BE102107373E8E3908F53AF54166D3F88ACE20CF266F1CD97D3A92221EEB079DBF7620C4BAEB8C407B768DFBD1D0F4C86CD3BC4B0F3DDAC5BEA2B649EB52B4ADEE05F512FBCD79B80C0130F211DEE7FB2BF65241C0D16417331BFDCB5685D36D0C7EC62B7328EEDC0E5623C5A6997808D0128F30E7DA56B512DF75336125B1669CE1F555EBC3EEF391999A3A896FEF34D2",
"E0060000E0E12BA3214461D8BB52CF79A60030C936FB14FD62A8B4A8DBD0B68E7D71C184817E1B65656CE1D6F01C717039DE0DCBA689A47CCDC8C6EC5A5A987212F69380B2861A6E66CB148E9F354A60F37FC93F89D126F3B62B8981D78C1DCA8F10C17631F79B266351695093900302E55A17C833553A50B7B7D0B0D2B3178C1DD182E1E67CC5DEBE6FBB3721B1EF378E84BC3B3E500AC0FF3556BD523A1A1E47D985909887074E93F26E237435F1EDD79E176C08CAF66F4E0B90319A713BD00428EB90196B53A6A36B2444399F147725164BAFB11C6970EC1062001BA7633E7CEB435139",
"E007000000",
"E00800000805677FBAB44A0309",
"E009000000",
];
|
/*! @license Firebase v4.5.0
Build: rev-f49c8b5
Terms: https://firebase.google.com/terms/ */
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.GrpcConnection = undefined;
var _app = require('../../app');
var _app2 = _interopRequireDefault(_app);
var _stream_bridge = require('../remote/stream_bridge');
var _rpc_error = require('../remote/rpc_error');
var _assert = require('../util/assert');
var _error = require('../util/error');
var _log = require('../util/log');
var log = _interopRequireWildcard(_log);
var _node_api = require('../util/node_api');
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var SDK_VERSION = _app2.default.SDK_VERSION;
// Trick the TS compiler & Google closure compiler into executing normal require
// statements, not using goog.require to import modules at compile time
/**
* Copyright 2017 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// TODO(dimond): The following imports have been replaced with require
// statements to not let the google closure compiler try to resolve them at
// compile time.
// import * as grpc from 'grpc';
// import * as protobufjs from 'protobufjs';
// import * as util from 'util';
var dynamicRequire = require;
var grpc = dynamicRequire('grpc');
var grpcVersion = dynamicRequire('grpc/package.json').version;
var util = dynamicRequire('util');
var LOG_TAG = 'Connection';
// TODO(b/38203344): The SDK_VERSION is set independently from Firebase because
// we are doing out-of-band releases. Once we release as part of Firebase, we
// should use the Firebase version instead.
var X_GOOG_API_CLIENT_VALUE = "gl-node/" + process.versions.node + " fire/" + SDK_VERSION + " grpc/" + grpcVersion;
function createHeaders(databaseInfo, token) {
(0, _assert.assert)(token === null || token.type === 'OAuth', 'If provided, token must be OAuth');
var channelCredentials = databaseInfo.ssl ? grpc.credentials.createSsl() : grpc.credentials.createInsecure();
var callCredentials = grpc.credentials.createFromMetadataGenerator(function (context, cb) {
var metadata = new grpc.Metadata();
if (token) {
for (var header in token.authHeaders) {
if (token.authHeaders.hasOwnProperty(header)) {
metadata.set(header, token.authHeaders[header]);
}
}
}
metadata.set('x-goog-api-client', X_GOOG_API_CLIENT_VALUE);
// This header is used to improve routing and project isolation by the
// backend.
metadata.set('google-cloud-resource-prefix', "projects/" + databaseInfo.databaseId.projectId + "/" + ("databases/" + databaseInfo.databaseId.database));
cb(null, metadata);
});
return grpc.credentials.combineChannelCredentials(channelCredentials, callCredentials);
}
/**
* A Connection implemented by GRPC-Node.
*/
var GrpcConnection = /** @class */function () {
function GrpcConnection(builder, databaseInfo) {
this.databaseInfo = databaseInfo;
// We cache stubs for the most-recently-used token.
this.cachedStub = null;
var protos = grpc.loadObject(builder.ns);
this.firestore = protos.google.firestore.v1beta1;
}
GrpcConnection.prototype.sameToken = function (tokenA, tokenB) {
var valueA = tokenA && tokenA.authHeaders['Authorization'];
var valueB = tokenB && tokenB.authHeaders['Authorization'];
return valueA === valueB;
};
// tslint:disable-next-line:no-any
GrpcConnection.prototype.getStub = function (token) {
if (!this.cachedStub || !this.sameToken(this.cachedStub.token, token)) {
log.debug(LOG_TAG, 'Creating datastore stubs.');
var credentials = createHeaders(this.databaseInfo, token);
this.cachedStub = {
stub: new this.firestore.Firestore(this.databaseInfo.host, credentials),
token: token
};
}
return this.cachedStub.stub;
};
GrpcConnection.prototype.invoke = function (rpcName, request, token) {
var stub = this.getStub(token);
return (0, _node_api.nodePromise)(function (callback) {
return stub[rpcName](request, function (grpcError, value) {
if (grpcError) {
log.debug(LOG_TAG, 'RPC "' + rpcName + '" failed with error ' + JSON.stringify(grpcError));
callback(new _error.FirestoreError((0, _rpc_error.mapCodeFromRpcCode)(grpcError.code), grpcError.message));
} else {
callback(undefined, value);
}
});
});
};
// TODO(mikelehen): This "method" is a monster. Should be refactored.
GrpcConnection.prototype.openStream = function (rpcName, token) {
var stub = this.getStub(token);
var grpcStream = stub[rpcName]();
var closed = false;
var close;
var remoteEnded = false;
var stream = new _stream_bridge.StreamBridge({
sendFn: function sendFn(msg) {
if (!closed) {
log.debug(LOG_TAG, 'GRPC stream sending:', util.inspect(msg, { depth: 100 }));
try {
grpcStream.write(msg);
} catch (e) {
// This probably means we didn't conform to the proto. Make sure to
// log the message we sent.
log.error(LOG_TAG, 'Failure sending: ', util.inspect(msg, { depth: 100 }));
log.error(LOG_TAG, 'Error: ', e);
throw e;
}
} else {
log.debug(LOG_TAG, 'Not sending because gRPC stream is closed:', util.inspect(msg, { depth: 100 }));
}
},
closeFn: function closeFn() {
close();
}
});
close = function close(err) {
if (!closed) {
closed = true;
stream.callOnClose(err);
grpcStream.end();
}
};
grpcStream.on('data', function (msg) {
if (!closed) {
log.debug(LOG_TAG, 'GRPC stream received: ', util.inspect(msg, { depth: 100 }));
stream.callOnMessage(msg);
}
});
grpcStream.on('end', function () {
log.debug(LOG_TAG, 'GRPC stream ended.');
// The server closed the remote end. Close our side too (which will
// trigger the 'finish' event).
remoteEnded = true;
grpcStream.end();
});
grpcStream.on('finish', function () {
// This means we've closed the write side of the stream. We either did
// this because the StreamBridge was close()ed or because we got an 'end'
// event from the grpcStream.
// TODO(mikelehen): This is a hack because of weird grpc-node behavior
// (https://github.com/grpc/grpc/issues/7705). The stream may be finished
// because we called end() because we got an 'end' event because there was
// an error. Now that we've called end(), GRPC should deliver the error,
// but it may take some time (e.g. 700ms). So we delay our close handling
// in case we receive such an error.
if (remoteEnded) {
setTimeout(close, 2500);
} else {
close();
}
});
grpcStream.on('error', function (grpcError) {
log.debug(LOG_TAG, 'GRPC stream error:', grpcError);
var code = (0, _rpc_error.mapCodeFromRpcCode)(grpcError.code);
close(new _error.FirestoreError(code, grpcError.message));
});
grpcStream.on('status', function (status) {
if (!closed) {
log.debug(LOG_TAG, 'GRPC stream received status:', status);
if (status.code === 0) {
// all good
} else {
var code = (0, _rpc_error.mapCodeFromRpcCode)(status.code);
close(new _error.FirestoreError(code, status.details));
}
}
});
log.debug(LOG_TAG, 'Opening GRPC stream');
// TODO(dimond): Since grpc has no explicit open status (or does it?) we
// simulate an onOpen in the next loop after the stream had it's listeners
// registered
setTimeout(function () {
stream.callOnOpen();
}, 0);
return stream;
};
return GrpcConnection;
}();
exports.GrpcConnection = GrpcConnection;
//# sourceMappingURL=grpc_connection.js.map
|
module.exports=require('../../decode-ranges.js')('wWwJAILaEEWANACAAZESZABhHBEAOAdxkgA4NsNYAEAAABABAhrgglqRg_Bg1gnLhzCAAAiG') |
/*===================================================*\
* Requires
\*===================================================*/
var merge = require('merge'),
CharacteristicManager = require('./characteristics/CharacteristicManager'),
JClass = require('jclass'),
HashArray = require('hasharray'),
EventDispatcher = require('./EventDispatcher');
/*===================================================*\
* GameObject()
\*===================================================*/
var GameObject = module.exports = EventDispatcher.extend({
/*======================*\
* Properties
\*======================*/
isServer: function () {
return typeof window === 'undefined';
},
stateSetProps: function() {
return [];
},
stateGetProps: function() {
return ['_id'];
},
setParent: function(value) {
this._parent = value;
},
getParent: function() {
return this._parent;
},
setChildren: function(value) {
// Deserialize from server
this._children = value;
},
getChildren: function() {
// Serialize from server
return this._children;
},
setId: function(value) {
this._id = value;
},
getId: function() {
return this._id || (this._id = this.randomId());
},
setState: function(value) {
this._state = value;
},
getState: function(mergeWith) {
if (!this.inited)
return {};
return this.merge.recursive(true, {
id: this.getId(),
type: this.type,
children: this.getChildren().all.map(function (child) {
return child.getState();
})
}, mergeWith);
},
getChildrenIds: function() {
if (!this.inited)
return {};
var ret = {};
this.getChildren().all.forEach(function (child) {
ret[child.getId()] = true;
});
return ret;
},
setChildrenState: function(value) {
var self = this,
ids = this.getChildrenIds();
value.forEach(function (childState) {
var child = self.getChildren().get(childState.id);
if (!child)
self.getChildren().add(self.newChildFromState(childState));
else {
if (Object.prototype.toString.call(child) === '[object Array]' )
{
console.log('Two ids are the same!', child[0].getId());
return;
}
child.setState(childState);
}
delete ids[childState.id];
});
if (this.destroyUnfoundChildrenOnStateSet)
for (var id in ids)
this.destroyChildById(id);
},
getChildrenState: function() {
if (!this.inited)
return {};
return this.getChildren().all.map(function (child) {
return child.getState();
});
},
setDirty: function(value) {
// Deserialize from server
this._dirty = value;
(this._dirty && this.getParent()) ? this.getParent().setDirty(true) : '';
!this._dirty ? this.getChildren().forEach(function (child) {
child.setDirty(false);
}) : '';
},
getDirty: function() {
// Serialize from server
return this._dirty;
},
/*======================*\
* Overridden Methods
\*======================*/
emit: function () {
this._super.apply(this, arguments);
// Bubbling
var p = this.getParent();
if (p)
p.emit.apply(p, arguments);
},
/*======================*\
* Methods
\*======================*/
randomId: function () {
return Math.round(Math.random() * 999999999).toString(16);
},
init: function (parent, id) {
if (!parent)
{
GameObject.prototype.world = GameObject.prototype.root = this;
}
this.merge = merge;
this.setId(id);
this.type = 'GameObject';
this.buildChildrenObject();
this.setParent(parent);
this.setDirty(true);
this.destroyed = false;
this.sprite = undefined;
this.destroyUnfoundChildrenOnStateSet = true;
this.charManager = new CharacteristicManager(this);
this.inited= true;
},
update: function (elapsed, tracker) {
if (tracker)
tracker.add(this);
var self = this;
// Wipe out any destroyed children.
this.getChildren().all.concat().forEach(function (child) {
if (child.destroyed)
self.getChildren().remove(child);
});
this.getChildren().all.forEach(function (child) {
child.update(elapsed, tracker);
});
this.charManager.applyAll(elapsed);
},
newChildFromState: function (childState) {
var child = new GameObject();
child.init(this, childState.id)
child.state = childState;
return child;
},
destroyChildById: function (id) {
var child = this.getChildren().get(id);
if (!child)
{
console.log('Attempting to destroy non-existent child with id', id);
return;
}
if (child.destroy)
{
child.destroy();
}
this.getChildren().remove(child);
},
buildChildrenObject: function () {
this.setChildren(new HashArray(['_id', 'type']));
},
buildSprite: function (phaser) {
},
updateSprite: function (phaser) {
if (this.sprite && this.destroyed)
this.sprite.destroy(true);
else
{
if (!this.sprite)
this.buildSprite(phaser);
if (this.sprite)
this.sprite.updateWithModel(this);
}
},
updatePhaser: function (phaser) {
this.getChildren().all.forEach(function (child) {
child.updatePhaser(phaser);
});
this.updateSprite(phaser);
},
destroy: function () {
this.destroyed = true;
},
forEach: function (callback, types) {
var children = types ? this.getChildren().getAll(types) : this.getChildren().all.concat();
children.forEach(function (child) {
child.forEach(callback, types);
});
if (!types || types.indexOf(this.type))
callback.apply(this);
}
}); |
var ADODBStream = WScript.CreateObject('ADODB.Stream');
ADODBStream.open();
ADODBStream.type = 1;
ADODBStream.loadFromFile('Write.js');
// ADODBStream.write(01011001);
ADODBStream.position = 0;
var bA = ADODBStream.read();
var stream = WScript.CreateObject('ADODB.Stream');
stream.open();
stream.type = 1;
stream.write(bA);
WScript.Echo(stream.position);
stream.position = 0;
WScript.Echo(stream.read(2));
WScript.Echo(stream.size); |
'use strict';
//Setting up route
angular.module('examinations').config(['$stateProvider',
function($stateProvider) {
// Examinations state routing
$stateProvider.
state('listExaminations', {
url: '/examinations',
templateUrl: 'modules/examinations/views/list-examinations.client.view.html',
action: 'list_examinations',
title:'Examinations'
}).
state('patientExaminations', {
url: '/examinations/patient/:patientId',
templateUrl: 'modules/examinations/views/patient-examinations.client.view.html',
action: 'list_examinations',
title:'Patient Examinations'
}).
state('searchExaminations', {
url: '/examinations/search',
templateUrl: 'modules/examinations/views/search-examinations.client.view.html',
action: 'list_examinations',
title:'Search Examinations'
}).
state('createExamination', {
url: '/examinations/create/:patientId',
templateUrl: 'modules/examinations/views/create-examination.client.view.html',
action: 'create_examination',
title:'New Examination'
}).
state('viewExamination', {
url: '/examinations/:examinationId',
templateUrl: 'modules/examinations/views/view-examination.client.view.html',
action: 'view_examination',
title:'View Examination'
}).
state('editExamination', {
url: '/examinations/:examinationId/edit',
templateUrl: 'modules/examinations/views/edit-examination.client.view.html',
action: 'edit_examination',
title:'Edit Examinations'
});
}
]);
|
/**
* Copyright 2012-2018, Plotly, Inc.
* All rights reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
'use strict';
var scatterAttrs = require('../scatter/attributes');
var plotAttrs = require('../../plots/attributes');
var colorAttributes = require('../../components/colorscale/color_attributes');
var colorbarAttrs = require('../../components/colorbar/attributes');
var extendFlat = require('../../lib/extend').extendFlat;
var scatterMarkerAttrs = scatterAttrs.marker,
scatterLineAttrs = scatterAttrs.line,
scatterMarkerLineAttrs = scatterMarkerAttrs.line;
module.exports = {
carpet: {
valType: 'string',
role: 'info',
editType: 'calc',
description: [
'An identifier for this carpet, so that `scattercarpet` and',
'`scattercontour` traces can specify a carpet plot on which',
'they lie'
].join(' ')
},
a: {
valType: 'data_array',
editType: 'calc',
description: [
'Sets the quantity of component `a` in each data point.',
'If `a`, `b`, and `c` are all provided, they need not be',
'normalized, only the relative values matter. If only two',
'arrays are provided they must be normalized to match',
'`ternary<i>.sum`.'
].join(' ')
},
b: {
valType: 'data_array',
editType: 'calc',
description: [
'Sets the quantity of component `a` in each data point.',
'If `a`, `b`, and `c` are all provided, they need not be',
'normalized, only the relative values matter. If only two',
'arrays are provided they must be normalized to match',
'`ternary<i>.sum`.'
].join(' ')
},
mode: extendFlat({}, scatterAttrs.mode, {dflt: 'markers'}),
text: extendFlat({}, scatterAttrs.text, {
description: [
'Sets text elements associated with each (a,b,c) point.',
'If a single string, the same string appears over',
'all the data points.',
'If an array of strings, the items are mapped in order to the',
'the data points in (a,b,c).'
].join(' ')
}),
line: {
color: scatterLineAttrs.color,
width: scatterLineAttrs.width,
dash: scatterLineAttrs.dash,
shape: extendFlat({}, scatterLineAttrs.shape,
{values: ['linear', 'spline']}),
smoothing: scatterLineAttrs.smoothing,
editType: 'calc'
},
connectgaps: scatterAttrs.connectgaps,
fill: extendFlat({}, scatterAttrs.fill, {
values: ['none', 'toself', 'tonext'],
description: [
'Sets the area to fill with a solid color.',
'Use with `fillcolor` if not *none*.',
'scatterternary has a subset of the options available to scatter.',
'*toself* connects the endpoints of the trace (or each segment',
'of the trace if it has gaps) into a closed shape.',
'*tonext* fills the space between two traces if one completely',
'encloses the other (eg consecutive contour lines), and behaves like',
'*toself* if there is no trace before it. *tonext* should not be',
'used if one trace does not enclose the other.'
].join(' ')
}),
fillcolor: scatterAttrs.fillcolor,
marker: extendFlat({
symbol: scatterMarkerAttrs.symbol,
opacity: scatterMarkerAttrs.opacity,
maxdisplayed: scatterMarkerAttrs.maxdisplayed,
size: scatterMarkerAttrs.size,
sizeref: scatterMarkerAttrs.sizeref,
sizemin: scatterMarkerAttrs.sizemin,
sizemode: scatterMarkerAttrs.sizemode,
line: extendFlat({
width: scatterMarkerLineAttrs.width,
editType: 'calc'
},
colorAttributes('marker'.line)
),
gradient: scatterMarkerAttrs.gradient,
editType: 'calc'
}, colorAttributes('marker'), {
showscale: scatterMarkerAttrs.showscale,
colorbar: colorbarAttrs
}),
textfont: scatterAttrs.textfont,
textposition: scatterAttrs.textposition,
selected: scatterAttrs.selected,
unselected: scatterAttrs.unselected,
hoverinfo: extendFlat({}, plotAttrs.hoverinfo, {
flags: ['a', 'b', 'text', 'name']
}),
hoveron: scatterAttrs.hoveron,
};
|
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var _throttle = _interopDefault(require('lodash.throttle'));
var SkyScrollPlugin = {
install: function install(Vue, options) {
var _defaults = {
throttle: 0,
};
var config = Object.assign({}, _defaults, options);
var _vm = new Vue({
data: function data() {
return {
scroll: {
x: 0,
y: 0,
deltaX: 0,
deltaY: 0,
directionX: 0,
directionY: 0,
last: {
x: 0,
y: 0,
deltaX: 0,
deltaY: 0,
directionX: 0,
directionY: 0,
},
},
window: {
width: 0,
height: 0,
},
document: {
width: 0,
height: 0,
},
};
},
created: function created() {
this.$on('recalculate', this._recalculateHandler);
},
methods: {
_scrollHandler: function _scrollHandler() {
this.$set(this.scroll, 'last', {
x: this.scroll.x,
y: this.scroll.y,
deltaX: this.scroll.deltaX,
deltaY: this.scroll.deltaY,
directionX: this.scroll.directionX,
directionY: this.scroll.directionY,
});
this.scroll.x = window.pageXOffset;
this.scroll.y = window.pageYOffset;
this.scroll.deltaX = this.scroll.x - this.scroll.last.x;
this.scroll.deltaY = this.scroll.y - this.scroll.last.y;
this.scroll.directionX = (this.scroll.deltaX < 0) ? -1 : 1;
this.scroll.directionY = (this.scroll.deltaY < 0) ? -1 : 1;
if (this.scroll.y + this.window.height > this.document.height) {
this.$emit('recalculate', 'resize');
}
this._emitScroll();
},
_resizeHandler: function _resizeHandler() {
this.window.width = window.innerWidth;
this.window.height = window.innerHeight;
this.document.height = document.documentElement.scrollHeight;
this.document.width = document.documentElement.scrollWidth;
this._emitResize();
},
_emitScroll: function _emitScroll() {
this.$emit('scroll', {
scroll: this.scroll,
window: this.window,
document: this.document,
});
},
_emitResize: function _emitResize() {
this.$emit('resize', {
scroll: this.scroll,
window: this.window,
document: this.document,
});
},
_recalculateHandler: function _recalculateHandler(type) {
if ( type === void 0 ) type = '';
if (!type || type === 'resize') {
this._resizeHandler.bind(this)();
}
if (!type || type === 'scroll') {
this._scrollHandler.bind(this)();
}
},
},
});
var $SkyScroll = {};
Object.defineProperties($SkyScroll, {
scroll: {
enumerable: true,
get: function get() {
return _vm.$data.scroll;
},
},
window: {
enumerable: true,
get: function get() {
return _vm.$data.window;
},
},
document: {
enumerable: true,
get: function get() {
return _vm.$data.document;
},
},
on: {
enumerable: true,
get: function get() {
return _vm.$on.bind(_vm);
},
},
once: {
enumerable: true,
get: function get() {
return _vm.$once.bind(_vm);
},
},
off: {
enumerable: true,
get: function get() {
return _vm.$off.bind(_vm);
},
},
emit: {
enumerable: true,
get: function get() {
return _vm.$emit.bind(_vm);
},
},
});
if (typeof window !== 'undefined') {
window.addEventListener('scroll', function () { return $SkyScroll.emit('recalculate', 'scroll'); });
window.addEventListener('resize', _throttle(function () { return $SkyScroll.emit('recalculate', 'resize'); }, config.throttle));
window.addEventListener('orientationchange', function () { return $SkyScroll.emit('recalculate', 'resize'); });
$SkyScroll.emit('recalculate');
}
// We implement a global mixin, that enables easy $SkyScroll config on any component
Vue.mixin({
$SkyScroll: {
onMounted: true, // Run scroll and resize functions on mounted by default
},
beforeCreate: function beforeCreate() {
var this$1 = this;
// Setup reactive $SkyScroll, $scroll and $window variables on instance
Vue.util.defineReactive(this, '$SkyScroll', $SkyScroll);
Vue.util.defineReactive(this, '$scroll', $SkyScroll.scroll);
Vue.util.defineReactive(this, '$window', $SkyScroll.window);
// Prepare _skyScroll - it will be used as a container object for various
// under the hood stuff
this._skyScroll = {};
// Get any options from custom $SkyScroll prop on instance
var ref = this.$options.$SkyScroll;
var scrollFn = ref.scroll;
var resizeFn = ref.resize;
var dimensions = ref.dimensions;
// If $SkyScroll.dimensions boolean is true:
// Keep track of root element dimensions on this.$dimensions
if (dimensions) {
// Setup $dimensions object on instance + make reactive
this.$dimensions = {
top: 0,
bottom: 0,
left: 0,
right: 0,
width: 0,
height: 0,
};
Vue.util.defineReactive(this, '$dimensions', this.$dimensions);
// Setup recalculate method on resize
this._skyScroll.recalculateDimensions = function () {
var bounds = this$1.$el.getBoundingClientRect();
var dim = {
top: bounds.top + this$1.$scroll.y,
bottom: bounds.top + this$1.$scroll.y,
left: bounds.left + this$1.$scroll.x,
right: bounds.right + this$1.$scroll.x,
width: bounds.width,
height: bounds.height,
};
this$1.$set(this$1, '$dimensions', dim);
return dim;
};
this.$SkyScroll.on('resize', this._skyScroll.recalculateDimensions);
}
// If $SkyScroll.scroll function on instance:
if (typeof scrollFn === 'function') {
// 1) Assign to _skyScroll so we keep track of it.
// 2) Make sure to bind(this) so this.whatever still works inside
this._skyScroll.scrollFn = scrollFn.bind(this);
this.$SkyScroll.on('scroll', this._skyScroll.scrollFn);
}
// If $SkyScroll.resize function on instance:
if (typeof resizeFn === 'function') {
// 1) Assign to _skyScroll so we keep track of it.
// 2) Make sure to bind(this) so this.whatever still works inside
this._skyScroll.resizeFn = resizeFn.bind(this);
this.$SkyScroll.on('resize', this._skyScroll.resizeFn);
}
},
mounted: function mounted() {
// Always calc dimensions when component is mounted
if (this.$dimensions) {
this._skyScroll.recalculateDimensions();
}
// Trigger scroll and resize on mounted if the onMounted option is true
// (it is by default)
if (this.$options.$SkyScroll.onMounted !== false) {
// $SkyScroll is a global instance by design - so it cannot trigger
// scroll or resize events whenever a component mounts - so we need
// to do it on each component manually (with the right arguments)
if (typeof this._skyScroll.scrollFn === 'function') {
this._skyScroll.scrollFn({
scroll: this.$SkyScroll.scroll,
window: this.$SkyScroll.window,
document: this.$SkyScroll.document,
});
}
if (typeof this._skyScroll.resizeFn === 'function') {
this.$SkyScroll.on('resize', this._skyScroll.resizeFn);
this._skyScroll.resizeFn({
scroll: this.$SkyScroll.scroll,
window: this.$SkyScroll.window,
document: this.$SkyScroll.document,
});
}
}
},
beforeDestroy: function beforeDestroy() {
// Clean up all $SkyScroll listeners that has been set on component destroy
if (this.$dimensions) {
this.$SkyScroll.off('resize', this._skyScroll.recalculateDimensions);
}
if (typeof this._skyScroll.scrollFn === 'function') {
this.$SkyScroll.off('scroll', this._skyScroll.scrollFn);
}
if (typeof this._skyScroll.resizeFn === 'function') {
this.$SkyScroll.off('resize', this._skyScroll.resizeFn);
}
},
});
},
};
exports.default = SkyScrollPlugin;
|
'use strict';
var path = require('path');
var assert = require('yeoman-assert');
var helpers = require('yeoman-test');
describe('generator-react-component:app', function () {
before(function (done) {
helpers.run(path.join(__dirname, '../generators/app'))
.withPrompts({someAnswer: true})
.on('end', done);
});
it('creates files', function () {
assert.file([
'dummyfile.txt'
]);
});
});
|
require(['backbone', 'marionette', 'modules/common/util','modules/simulator/DisplayUtil', 'modules/common/Router', 'modules/common/Controller','modules/main/MainView'], function (Backbone,Marionette, Util, DisplayUtil, Router, Controller, MainView) {
window.util = Util;
window.displayUtil = DisplayUtil;
window.app = new Marionette.Application();
app.appRouter = new Router({controller: new Controller()});
app.rootView = new MainView();
app.start();
Backbone.history.start({ pushState: true, root: '/' });
}); |
/**
* The global state selectors
*/
import { createSelector } from 'reselect';
export const selectGlobal = (state) => state.get('global');
export const makeSelectCurrentUser = () => createSelector(
selectGlobal,
(globalState) => globalState.get('currentUser')
);
export const makeSelectLoading = () => createSelector(
selectGlobal,
(globalState) => globalState.get('loading')
);
export const makeSelectError = () => createSelector(
selectGlobal,
(globalState) => globalState.get('error')
);
export const makeSelectRepos = () => createSelector(
selectGlobal,
(globalState) => globalState.getIn(['userData', 'repositories'])
);
export const makeSelectLocationState = () => {
let prevRoutingState;
let prevRoutingStateJS;
return (state) => {
const routingState = state.get('route'); // or state.route
if (!routingState.equals(prevRoutingState)) {
prevRoutingState = routingState;
prevRoutingStateJS = routingState.toJS();
}
return prevRoutingStateJS;
};
};
const getRouter = (state) => state.get('router');
export const makeSelectLocation = () => createSelector(
getRouter,
(router) => router.get('location'),
);
export const makeSelectDrawer = () => createSelector(
selectGlobal,
(state) => state.get('drawer')
);
// export {
// selectGlobal,
// makeSelectCurrentUser,
// makeSelectLoading,
// makeSelectError,
// makeSelectRepos,
// makeSelectLocationState,
// };
|
/*var Vec3 = require('../math/Vec3');
var Transform = require('../math/Transform');
var RaycastResult = require('../collision/RaycastResult');
var Utils = require('../utils/Utils');
module.exports = WheelInfo;*/
/**
* @class WheelInfo
* @constructor
* @param {Object} [options]
*
* @param {Vec3} [options.chassisConnectionPointLocal]
* @param {Vec3} [options.chassisConnectionPointWorld]
* @param {Vec3} [options.directionLocal]
* @param {Vec3} [options.directionWorld]
* @param {Vec3} [options.axleLocal]
* @param {Vec3} [options.axleWorld]
* @param {number} [options.suspensionRestLength=1]
* @param {number} [options.suspensionMaxLength=2]
* @param {number} [options.radius=1]
* @param {number} [options.suspensionStiffness=100]
* @param {number} [options.dampingCompression=10]
* @param {number} [options.dampingRelaxation=10]
* @param {number} [options.frictionSlip=10000]
* @param {number} [options.steering=0]
* @param {number} [options.rotation=0]
* @param {number} [options.deltaRotation=0]
* @param {number} [options.rollInfluence=0.01]
* @param {number} [options.maxSuspensionForce]
* @param {number} [options.isFrontWheel=true]
* @param {number} [options.clippedInvContactDotSuspension=1]
* @param {number} [options.suspensionRelativeVelocity=0]
* @param {number} [options.suspensionForce=0]
* @param {number} [options.skidInfo=0]
* @param {number} [options.suspensionLength=0]
* @param {number} [options.maxSuspensionTravel=1]
* @param {number} [options.useCustomSlidingRotationalSpeed=false]
* @param {number} [options.customSlidingRotationalSpeed=-0.1]
*/
function WheelInfo(options){
options = Utils.defaults(options, {
chassisConnectionPointLocal: new CANNON.Vec3(),
chassisConnectionPointWorld: new CANNON.Vec3(),
directionLocal: new CANNON.Vec3(),
directionWorld: new CANNON.Vec3(),
axleLocal: new CANNON.Vec3(),
axleWorld: new CANNON.Vec3(),
suspensionRestLength: 1,
suspensionMaxLength: 2,
radius: 1,
suspensionStiffness: 100,
dampingCompression: 10,
dampingRelaxation: 10,
frictionSlip: 10000,
steering: 0,
rotation: 0,
deltaRotation: 0,
rollInfluence: 0.01,
maxSuspensionForce: Number.MAX_VALUE,
isFrontWheel: true,
clippedInvContactDotSuspension: 1,
suspensionRelativeVelocity: 0,
suspensionForce: 0,
skidInfo: 0,
suspensionLength: 0,
maxSuspensionTravel: 1,
useCustomSlidingRotationalSpeed: false,
customSlidingRotationalSpeed: -0.1
});
/**
* Max travel distance of the suspension, in meters.
* @property {number} maxSuspensionTravel
*/
this.maxSuspensionTravel = options.maxSuspensionTravel;
/**
* Speed to apply to the wheel rotation when the wheel is sliding.
* @property {number} customSlidingRotationalSpeed
*/
this.customSlidingRotationalSpeed = options.customSlidingRotationalSpeed;
/**
* If the customSlidingRotationalSpeed should be used.
* @property {Boolean} useCustomSlidingRotationalSpeed
*/
this.useCustomSlidingRotationalSpeed = options.useCustomSlidingRotationalSpeed;
/**
* @property {Boolean} sliding
*/
this.sliding = false;
/**
* Connection point, defined locally in the chassis body frame.
* @property {Vec3} chassisConnectionPointLocal
*/
this.chassisConnectionPointLocal = options.chassisConnectionPointLocal.clone();
/**
* @property {Vec3} chassisConnectionPointWorld
*/
this.chassisConnectionPointWorld = options.chassisConnectionPointWorld.clone();
/**
* @property {Vec3} directionLocal
*/
this.directionLocal = options.directionLocal.clone();
/**
* @property {Vec3} directionWorld
*/
this.directionWorld = options.directionWorld.clone();
/**
* @property {Vec3} axleLocal
*/
this.axleLocal = options.axleLocal.clone();
/**
* @property {Vec3} axleWorld
*/
this.axleWorld = options.axleWorld.clone();
/**
* @property {number} suspensionRestLength
*/
this.suspensionRestLength = options.suspensionRestLength;
/**
* @property {number} suspensionMaxLength
*/
this.suspensionMaxLength = options.suspensionMaxLength;
/**
* @property {number} radius
*/
this.radius = options.radius;
/**
* @property {number} suspensionStiffness
*/
this.suspensionStiffness = options.suspensionStiffness;
/**
* @property {number} dampingCompression
*/
this.dampingCompression = options.dampingCompression;
/**
* @property {number} dampingRelaxation
*/
this.dampingRelaxation = options.dampingRelaxation;
/**
* @property {number} frictionSlip
*/
this.frictionSlip = options.frictionSlip;
/**
* @property {number} steering
*/
this.steering = 0;
/**
* Rotation value, in radians.
* @property {number} rotation
*/
this.rotation = 0;
/**
* @property {number} deltaRotation
*/
this.deltaRotation = 0;
/**
* @property {number} rollInfluence
*/
this.rollInfluence = options.rollInfluence;
/**
* @property {number} maxSuspensionForce
*/
this.maxSuspensionForce = options.maxSuspensionForce;
/**
* @property {number} engineForce
*/
this.engineForce = 0;
/**
* @property {number} brake
*/
this.brake = 0;
/**
* @property {number} isFrontWheel
*/
this.isFrontWheel = options.isFrontWheel;
/**
* @property {number} clippedInvContactDotSuspension
*/
this.clippedInvContactDotSuspension = 1;
/**
* @property {number} suspensionRelativeVelocity
*/
this.suspensionRelativeVelocity = 0;
/**
* @property {number} suspensionForce
*/
this.suspensionForce = 0;
/**
* @property {number} skidInfo
*/
this.skidInfo = 0;
/**
* @property {number} suspensionLength
*/
this.suspensionLength = 0;
/**
* @property {number} sideImpulse
*/
this.sideImpulse = 0;
/**
* @property {number} forwardImpulse
*/
this.forwardImpulse = 0;
/**
* The result from raycasting
* @property {RaycastResult} raycastResult
*/
this.raycastResult = new CANNON.RaycastResult();
/**
* Wheel world transform
* @property {Transform} worldTransform
*/
this.worldTransform = new Transform();
/**
* @property {boolean} isInContact
*/
this.isInContact = false;
}
var chassis_velocity_at_contactPoint = new CANNON.Vec3();
var relpos = new CANNON.Vec3();
var chassis_velocity_at_contactPoint = new CANNON.Vec3();
WheelInfo.prototype.updateWheel = function(chassis){
var raycastResult = this.raycastResult;
if (this.isInContact){
var project= raycastResult.hitNormalWorld.dot(raycastResult.directionWorld);
raycastResult.hitPointWorld.vsub(chassis.position, relpos);
chassis.getVelocityAtWorldPoint(relpos, chassis_velocity_at_contactPoint);
var projVel = raycastResult.hitNormalWorld.dot( chassis_velocity_at_contactPoint );
if (project >= -0.1) {
this.suspensionRelativeVelocity = 0.0;
this.clippedInvContactDotSuspension = 1.0 / 0.1;
} else {
var inv = -1 / project;
this.suspensionRelativeVelocity = projVel * inv;
this.clippedInvContactDotSuspension = inv;
}
} else {
// Not in contact : position wheel in a nice (rest length) position
raycastResult.suspensionLength = this.suspensionRestLength;
this.suspensionRelativeVelocity = 0.0;
raycastResult.directionWorld.scale(-1, raycastResult.hitNormalWorld);
this.clippedInvContactDotSuspension = 1.0;
}
}; |
/**
* Test for ctxInjector.
* Runs with mocha.
*/
'use strict'
const ctxInjector = require('../lib/helpers/ctxInjector')
const { ok, equal } = require('assert')
describe('ctx-injector', () => {
before(() => {
})
after(() => {
})
it('Do test', () => {
})
})
/* global describe, before, after, it */
|
import React, { Component } from 'react';
import { connect } from 'react-redux';
import axios from 'axios';
import qs from 'qs';
@connect((store) => {
return {
currClass: store.globalReducer.currClass,
currTeam: store.globalReducer.currTeam,
students: store.globalReducer.students
}
})
class InstrDash extends Component {
getAvgGrade(classNum, teamNum, student) {
var pid = student.pid;
var res;
var param = {
classNum: classNum,
teamNum: teamNum,
pid: pid
}
const request = axios.post('/cumulativeAverage/', qs.stringify(param));
request.then((response)=>{
console.log(response.data);
res = response.data
});
return 1;
};
render() {
var {students, currTeam, currClass} = this.props;
var studentItems = students.map((student) => {
return(
<tr key={student.student}>
<td>{student.student}</td>
<td>{this.getAvgGrade(currClass, currTeam, student)}</td>
<td>View Review</td>
</tr>
)
});
return (
<div className ="container">
<h2>Team {this.props.currTeam} </h2>
<table className = "table table-hover">
<thead>
<tr>
<th> Student Lastname, Firstname</th>
<th> Assigned Grade </th>
<th> Reviews </th>
</tr>
</thead>
<tbody>
{studentItems}
</tbody>
</table>
</div>
);
};
};
export default connect(null, null)(InstrDash);
|
var express = require('express');
var swig = require('swig');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var compression = require('compression');
var cluster = require('cluster');
var app = express();
var env = app.get('env') || 'development';
app.set('env', env);
var boot = function(){
app.set('port', process.env.PORT || 8150);
app.engine('tpl', swig.renderFile);
app.set('view engine', 'tpl');
app.set('views', __dirname + '/templates');
if ('development' == env) {
app.set('view cache', false);
swig.setDefaults({cache: false});
}
//app.use(cookieParser('user_specified')); //session encrypted cookie
//app.use(bodyParser.urlencoded({ extended: false })); // post body
app.use(compression()); // gzip
app.use(function(req, res, next) {
//Can add some request intercepter
next();
});
// load route
require('fs').readdirSync(__dirname + '/routes').forEach(function(file) {
require(__dirname + '/routes/' + file)(app);
});
app.use(function(req, res, next) {
res.status(404).json({ERROR: 'Page not found.'});
});
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).json({ERROR: 'Internal server error.'});
});
app.listen(app.get('port'));
console.log('Application Started on http://localhost:' + app.get('port'));
};
if (cluster.isMaster && app.get('env') == 'production') { // Add cluster support
var cpuCount = require('os').cpus().length;
for (var i = 0; i < cpuCount; i++) {
cluster.fork();
}
} else {
boot();
//require('./utils/functions').swig(swig); //swig extension
}
|
const jobName = 'noStages';
/** @module noStages
* @memberof karaoke
* @description TEST: logs tailing a pipeline job without stages, but with steps - karaoke mode
*/
module.exports = {
/** Create Pipeline Job "noStages" */
'Step 01': function (browser) {
const pipelinesCreate = browser.page.pipelineCreate().navigate();
pipelinesCreate.createPipeline(jobName, 'no-stages.groovy');
},
/** Build Pipeline Job*/
'Step 02': function (browser) {
const pipelinePage = browser.page.jobUtils().forJob(jobName);
pipelinePage.buildStarted(function() {
// Reload the job page and check that there was a build done.
pipelinePage
.forRun(1)
.waitForElementVisible('@executer');
});
},
/** Check Job Blue Ocean Pipeline Activity Page has run - stop follow
* need to click on an element so the up_arrow takes place in the window
* */
'Step 03': function (browser) {
const blueActivityPage = browser.page.bluePipelineActivity().forJob(jobName, 'jenkins');
// Check the run itself
blueActivityPage.waitForRunRunningVisible('noStages', '1');
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
// Wait for the table of pipeline steps to start rendering with
// follow-on turned on.
blueRunDetailPage.waitForElementVisible('@followAlongOn');
// The log appears in the <code> window, of which there an be only one.
// Click on it to focus it so we make sure the key up is fired on the page and
// not directly on the browser
browser.waitForElementVisible('pre')
.click('pre');
// Wait for the "step-7" to appear before we stop the karaoke.
// See no-stages.groovy.
browser.waitForElementVisible('.logConsole.step-7');
// Press the up-arrow key to tell karaoke mode to stop following the log i.e.
// after this point in time, the content of the <pre> block should not change.
browser.keys(browser.Keys.UP_ARROW);
// Wait for the table of pipeline steps to get marked with
// follow-on turned off. Then we know for sure that karaoke
// mode should not be running and step rendering should be "static".
blueRunDetailPage.waitForElementVisible('@followAlongOff');
// So, because we have pressed the up-arrow (see above), the karaoke
// should stop. So if we now wait a bit, we should NOT see
// more elements than before. If we do, that means that karaoke did not stop and
// something is wrong with the up-arrow listener.
//
// Note that there must be enough time in the test script for the following code to execute before
// the run ends. If not, the following test will fail because the end event for the run
// will arrive during the pause, causing the list of steps to get re-rendered and for
// the test to then think karaoke stop (from the earlier up-arrow) is not working.
// So, make sure the sleeps in no-stages.groovy are long enough to cover this. Remember
// that the CI servers run a bit slower, so time needs to be given for that.
//
browser.elements('css selector', 'div.result-item', function (resutlItems) {
var results = resutlItems.value.length;
// to validate that we left follow, give it some time and then count the elements again
this.pause(3000)
.elements('css selector', 'pre', function (codeCollection) {
// JENKINS-36700 there can only be one code view open in follow stopped
this.assert.equal(codeCollection.value.length, 1);
})
.elements('css selector', 'div.result-item', function (resutlItemsCompare) {
// there should not be more items then we had before
this.assert.equal( resutlItemsCompare.value.length, results);
})
});
blueRunDetailPage.assertBasicLayoutOkay();
},
/** Check Job Blue Ocean Pipeline run detail page - follow*/
'Step 04': function (browser) {
// Reload the page so as to restart karaoke mode
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
browser.elements('css selector', 'div.result-item.success', function (collection) {
const count = collection.value.length;
// wait for the success update via sse event
this.waitForElementVisible('.BasicHeader--success');
blueRunDetailPage.fullLogButtonNotPresent();
this
.elements('css selector', 'div.result-item.success', function (collection2) {
const count2 = collection2.value.length;
this.assert.notEqual(count, count2);
})
.elements('css selector', 'pre', function (codeCollection) {
// JENKINS-36700 in success all code should be closed,
// however if the browser is too quick there can still be one open
this.assert.equal(codeCollection.value.length < 2, true);
})
;
});
},
/** Check whether a log which exceed 150kb contains a link to full log and if clicked it disappear*/
'Step 05': function (browser) {
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
browser.waitForJobRunEnded(jobName, function() {
// Note, tried using "last" selectors for both CSS and XPath
// and neither worked in nightwatch e.g. //div[starts-with(@class, 'logConsole')][last()]
// works in the browser, but not for nightwatch.
// NOTE: if the pipeline script (no-stages.groovy) changes then the following
// selector will need to be changed too.
var lastLogConsoleSelector = '.logConsole.step-11';
blueRunDetailPage.waitForElementVisible(lastLogConsoleSelector);
blueRunDetailPage.click(lastLogConsoleSelector);
// request full log
blueRunDetailPage.clickFullLog();
});
},
/** Check whether a step that does not has a log as well will have the expando disabled*/
'Step 06': function (browser) {
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
// NOTE: if the pipeline script (no-stages.groovy) changes then the following
// selector will need to be changed too.
browser
.waitForElementVisible('div.step-29 svg.disabled.result-item-expando');
},
/** Check whether the test tab shows an empty state hint*/
'Step 07': function (browser) {
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
blueRunDetailPage.clickTab('tests');
blueRunDetailPage.validateEmpty();
},
/** Check whether the changes tab shows an empty state hint*/
'Step 08': function (browser) {
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
blueRunDetailPage.clickTab('changes');
blueRunDetailPage.validateEmpty();
},
/** Check whether the artifacts tab shows an empty state hint*/
'Step 09': function (browser) {
const blueRunDetailPage = browser.page.bluePipelineRunDetail().forRun(jobName, 'jenkins', 1);
blueRunDetailPage.clickTab('artifacts');
browser.elements('css selector', '.TableCell--actions', function (resutlItems) {
this.assert.equal(resutlItems.value.length, 1);
});
}
};
|
/*jshint undef:false */
(function (window) {
var document = window.document;
var script = document.createElement('script');
var sibling = document.getElementsByTagName('script')[0];
script.src = 'submit/waterfall-subscription-widget.1.0.0.js';
script.async = true;
script.type = 'text/javascript';
sibling.parentNode.insertBefore(script, sibling);
}(this));
|
const config = require('./config/webpack.config.dev.js');
module.exports = config;
|
/** @jsx html */
import { html } from '../../../snabbdom-jsx';
import Type from 'union-type';
import { bind, pipe, isBoolean, targetValue, targetChecked } from './helpers';
import { KEY_ENTER } from './constants';
import Task from './task';
// model : { nextID: Number, editingTitle: String, tasks: [task.model], filter: String }
const Action = Type({
Input : [String],
Add : [String],
Remove : [Number],
Archive : [],
ToggleAll : [isBoolean],
Filter : [String],
Modify : [Number, Task.Action]
});
function onInput(handler, e) {
if(e.keyCode === KEY_ENTER) {
handler(Action.Add(e.target.value));
}
}
function view({model, handler}) {
const remaining = remainingTodos(model.tasks);
const filtered = filteredTodos(model.tasks, model.filter);
return <section selector=".todoapp">
<header selector=".header" >
<h1>todos</h1>
<input
selector=".new-todo"
placeholder="What needs to be done?"
value={model.editingTitle}
on-input={pipe(targetValue, Action.Input, handler)}
on-keydown={bind(onInput, handler)} />
</header>
<section
selector=".main"
style-display={ model.tasks.length ? 'block' : 'none' }>
<input
selector=".toggle-all"
type="checkbox"
checked={ remaining === 0 }
on-click={ pipe(targetChecked, Action.ToggleAll, handler) } />
<ul selector=".todo-list">
{ filtered.map( task => <TodoItem item={task} handler={handler} /> ) }
</ul>
</section>
<footer
selector=".footer"
style-display={ model.tasks.length ? 'block' : 'none' }>
<span classNames="todo-count">
<strong>{remaining}</strong> item{remaining === 1 ? '' : 's'} left
</span>
<ul selector=".filters">
<li><a href="#/" class-selected={model.filter === 'all'}>All</a></li>
<li><a href="#/active" class-selected={model.filter === 'active'}>Active</a></li>
<li><a href="#/completed" class-selected={model.filter === 'completed'}>Completed</a></li>
</ul>
<button
classNames="clear-completed"
on-click={ bind(handler, Action.Archive()) }>Clear completed</button>
</footer>
</section>
}
const TodoItem = ({item, handler}) =>
<Task
model={item}
handler={ action => handler(Action.Modify(item.id, action)) }
onRemove={ bind(handler, Action.Remove(item.id)) } />
function init(handler) {
window.addEventListener('hashchange',
_ => handler(Action.Filter(window.location.hash.substr(2) || 'all')));
return {
nextID: 1,
tasks: [],
editingTitle: '',
filter: 'all'
};
}
function remainingTodos(tasks) {
return tasks.reduce( (acc, task) => !task.done ? acc+1 : acc, 0);
}
function filteredTodos(tasks, filter) {
return filter === 'completed' ? tasks.filter( todo => todo.done )
: filter === 'active' ? tasks.filter( todo => !todo.done )
: tasks;
}
function addTodo(model, title) {
return {...model,
tasks : [ ...model.tasks,
Task.init(model.nextID, title)],
editingTitle : '',
nextID : model.nextID + 1
}
}
function removeTodo(model, id) {
return {...model,
tasks : model.tasks.filter( taskModel => taskModel.id !== id )
};
}
function archiveTodos(model, id) {
return {...model,
tasks : model.tasks.filter( taskModel => !taskModel.done )
};
}
function toggleAll(model, done) {
return {...model,
tasks : model.tasks.map( taskModel => Task.update(taskModel, Task.Action.Toggle(done)) )
};
}
function modifyTodo(model ,id, action) {
return {...model,
tasks : model.tasks.map( taskModel => taskModel.id !== id ? taskModel : Task.update(taskModel, action) )
};
}
function update(model, action) {
return Action.case({
Input : editingTitle => ({...model, editingTitle}),
Add : title => addTodo(model, title),
Remove : id => removeTodo(model, id),
Archive : () => archiveTodos(model),
ToggleAll : done => toggleAll(model, done),
Filter : filter => ({...model, filter }),
Modify : (id, action) => modifyTodo(model, id, action)
}, action);
}
export default { view, init, update, Action }
|
version https://git-lfs.github.com/spec/v1
oid sha256:be40e33689bd3f6df14831dddafc6a67db6f0ab121ce993ff48486182bae98b6
size 55359
|
/*
* An environment is just an object that maps identifiers to JLambda expressions
* with a few built-in (a standard Prelude environment)
*/
import errors from "./errors.js";
import rep from "./representation.js";
// creates a new environment initialized with the pairs in values
function makeEnv(name, values) {
var env = {};
env.name = name;
env.bindings = {};
for (var i = 0; i < values.length; i++) {
name = values[i][0];
var val = values[i][1];
env.bindings[name] = val;
}
return env;
}
function lookup(name, env) {
var value = env.bindings[name];
if (!value) {
throw errors.JUnboundError(name, env.name);
}
return value;
}
export default {
lookup : lookup,
makeEnv : makeEnv
};
|
'use strict';
var mongoose = require('mongoose');
var Governance = mongoose.model('Governance');
var modelClass = require('../modelClass');
var renderModel = new modelClass.RenderModel( Governance, 'governance/governance.tex', 'governance/na.tex');
var is = require('is-js');
var defaultData = require('../default.json');
var _ = require('underscore');
/*
will explicitly populate the report with
the data you provide
*/
renderModel.setDebugPopulate( false, {
info: 'Debug String'
});
/*
will explicitly print the N/A latex
to the screen for debugging purposes
*/
renderModel.isDebugNull = false;
/*
render function that finds the obj in the database
and converts it into latex.
*/
module.exports.render = function(req, callback) {
renderModel.renderHTML(req, callback);
};
/*
Gets the data from the frontend and
saves it in the database.
*/
module.exports.submit = function(req, callback) {
if (is.empty(req.body.governance)) return callback(null, null);
var gov = new Governance({
info: req.body.governance.info,
user: req.user
});
gov.save(function(err) {
callback(err, gov);
});
};
module.exports.createDefaultData = function(report, user, cb) {
var save = _.extend(defaultData.governance, {
report: report,
user: user
});
var governance = new Governance(save);
governance.save(function(err) {
cb(err, governance);
});
};
module.exports.createPrevious = function(report, user, prevId, cb) {
renderModel.createPrevious(Governance, {governance: undefined}, report, user, prevId, cb);
};
|
import './app'
import './query'
import './mutation'
import './subscription'
import './relations'
import './directive'
|
/**
* Functionality specific to Twenty Thirteen.
*
* Provides helper functions to enhance the theme experience.
*/
( function( $ ) {
var body = $( 'body' ),
_window = $( window );
/**
* Adds a top margin to the footer if the sidebar widget area is higher
* than the rest of the page, to help the footer always visually clear
* the sidebar.
*/
$( function() {
if ( body.is( '.sidebar' ) ) {
var sidebar = $( '#secondary .widget-area' ),
secondary = ( 0 == sidebar.length ) ? -40 : sidebar.height(),
margin = $( '#tertiary .widget-area' ).height() - $( '#content' ).height() - secondary;
if ( margin > 0 && _window.innerWidth() > 999 )
$( '#colophon' ).css( 'margin-top', margin + 'px' );
}
} );
/**
* Enables menu toggle for small screens.
*/
( function() {
var nav = $( '#site-navigation' ), button, menu;
if ( ! nav )
return;
button = nav.find( '.menu-toggle' );
if ( ! button )
return;
// Hide button if menu is missing or empty.
menu = nav.find( '.nav-menu' );
if ( ! menu || ! menu.children().length ) {
button.hide();
return;
}
$( '.menu-toggle' ).on( 'click.twentythirteen', function() {
nav.toggleClass( 'toggled-on' );
} );
} )();
/**
* Makes "skip to content" link work correctly in IE9 and Chrome for better
* accessibility.
*
* @link http://www.nczonline.net/blog/2013/01/15/fixing-skip-to-content-links/
*/
_window.on( 'hashchange.twentythirteen', function() {
var element = document.getElementById( location.hash.substring( 1 ) );
if ( element ) {
if ( ! /^(?:a|select|input|button|textarea)$/i.test( element.tagName ) )
element.tabIndex = -1;
element.focus();
}
} );
/**
* Arranges footer widgets vertically.
*/
if ( $.isFunction( $.fn.masonry ) ) {
var columnWidth = body.is( '.sidebar' ) ? 228 : 245;
$( '#secondary .widget-area' ).masonry( {
itemSelector: '.widget',
columnWidth: columnWidth,
gutterWidth: 20,
isRTL: body.is( '.rtl' )
} );
}
} )( jQuery ); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.