text:
/**
 * Foundation for Sites by ZURB
 * Version 6.4.1
 * foundation.zurb.com
 * Licensed under MIT Open Source
 */
.media-object {
  display: block;
  margin-bottom: 1rem; }
  .media-object img {
    max-width: none; }
  @media screen and (max-width: 39.9375em) {
    .media-object.stack-for-small .media-object-section {
      padding: 0;
      padding-bottom: 2rem;
      display: block; }
      .media-object.stack-for-small .media-object-section img {
        width: 100%; } }

.media-object-section {
  display: table-cell;
  vertical-align: top; }
  .media-object-section:first-child {
    padding-right: 2rem; }
  .media-object-section:last-child:not(:nth-child(2)) {
    padding-left: 2rem; }
  .media-object-section > :last-child {
    margin-bottom: 0; }
  .media-object-section.middle {
    vertical-align: middle; }
  .media-object-section.bottom {
    vertical-align: bottom; }

@media print, screen and (min-width: 40em) {
  .with-divider {
    position: relative; }
    .with-divider:after {
      content: "|";
      position: absolute;
      right: 1rem;
      top: 0; } }

/*# sourceMappingURL=media-object.css.map */


text:
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
* @name: S15.5.4.15_A2_T2;
* @section: 15.5.4.15;
* @assertion: String.prototype.substring (start, end) returns a string value(not object);
* @description: start is NaN, end is Infinity;
*/

__string = new String('this is a string object');

//////////////////////////////////////////////////////////////////////////////
//CHECK#1
if (__string.substring(NaN, Infinity) !== "this is a string object") {
  $ERROR('#1: __string = new String(\'this is a string object\'); __string.substring(NaN, Infinity) === "this is a string object". Actual: '+__string.substring(NaN, Infinity) );
}
//
//////////////////////////////////////////////////////////////////////////////

redpajama_set_name: RedPajamaGithub


text:
package io.cdap.plugin.datagen.generator;

import io.cdap.plugin.datagen.DataGenerator;
import io.cdap.plugin.datagen.GeneratorContext;

/**
 * Generates longs in a regular sequence.
 */
public class SequentialLongGenerator implements DataGenerator<Long> {
  private final Config config;
  private long current;

  public SequentialLongGenerator(Config config) {
    this.config = config;
  }

  @Override
  public void initialize(GeneratorContext context) {
    current = config.start + context.getOffset() * config.step;
  }

  @Override
  public Long generate() {
    long val = current;
    current += config.step;
    return val;
  }

  /**
   * Config.
   */
  public static class Config {
    private long start;
    private long step;

    public Config() {
      this(0, 1);
    }

    public Config(long start, long step) {
      this.start = start;
      this.step = step;
    }
  }
}


text:
from .instance_view_status import InstanceViewStatus
from .sub_resource import SubResource
from .sku import Sku
from .availability_set import AvailabilitySet
from .virtual_machine_size import VirtualMachineSize
from .virtual_machine_extension_image import VirtualMachineExtensionImage
from .virtual_machine_image_resource import VirtualMachineImageResource
from .virtual_machine_extension_instance_view import VirtualMachineExtensionInstanceView
from .virtual_machine_extension import VirtualMachineExtension
from .purchase_plan import PurchasePlan
from .os_disk_image import OSDiskImage
from .data_disk_image import DataDiskImage
from .virtual_machine_image import VirtualMachineImage
from .usage_name import UsageName
from .usage import Usage
from .virtual_machine_capture_parameters import VirtualMachineCaptureParameters
from .virtual_machine_capture_result import VirtualMachineCaptureResult
from .plan import Plan
from .hardware_profile import HardwareProfile
from .image_reference import ImageReference
from .key_vault_secret_reference import KeyVaultSecretReference
from .key_vault_key_reference import KeyVaultKeyReference
from .disk_encryption_settings import DiskEncryptionSettings
from .virtual_hard_disk import VirtualHardDisk
from .managed_disk_parameters import ManagedDiskParameters
from .os_disk import OSDisk
from .data_disk import DataDisk
from .storage_profile import StorageProfile
from .additional_unattend_content import AdditionalUnattendContent
from .win_rm_listener import WinRMListener
from .win_rm_configuration import WinRMConfiguration
from .windows_configuration import WindowsConfiguration
from .ssh_public_key import SshPublicKey
from .ssh_configuration import SshConfiguration
from .linux_configuration import LinuxConfiguration
from .vault_certificate import VaultCertificate
from .vault_secret_group import VaultSecretGroup
from .os_profile import OSProfile
from .network_interface_reference import NetworkInterfaceReference
from .network_profile import NetworkProfile
from .boot_diagnostics import BootDiagnostics
from .diagnostics_profile import DiagnosticsProfile
from .virtual_machine_extension_handler_instance_view import VirtualMachineExtensionHandlerInstanceView
from .virtual_machine_agent_instance_view import VirtualMachineAgentInstanceView
from .disk_instance_view import DiskInstanceView
from .boot_diagnostics_instance_view import BootDiagnosticsInstanceView
from .virtual_machine_identity import VirtualMachineIdentity
from .virtual_machine_instance_view import VirtualMachineInstanceView
from .virtual_machine import VirtualMachine
from .upgrade_policy import UpgradePolicy
from .image_os_disk import ImageOSDisk
from .image_data_disk import ImageDataDisk
from .image_storage_profile import ImageStorageProfile
from .image import Image
from .virtual_machine_scale_set_identity import VirtualMachineScaleSetIdentity
from .virtual_machine_scale_set_os_profile import VirtualMachineScaleSetOSProfile
from .virtual_machine_scale_set_managed_disk_parameters import VirtualMachineScaleSetManagedDiskParameters
from .virtual_machine_scale_set_os_disk import VirtualMachineScaleSetOSDisk
from .virtual_machine_scale_set_data_disk import VirtualMachineScaleSetDataDisk
from .virtual_machine_scale_set_storage_profile import VirtualMachineScaleSetStorageProfile
from .api_entity_reference import ApiEntityReference
from .virtual_machine_scale_set_ip_configuration import VirtualMachineScaleSetIPConfiguration
from .virtual_machine_scale_set_network_configuration import VirtualMachineScaleSetNetworkConfiguration
from .virtual_machine_scale_set_network_profile import VirtualMachineScaleSetNetworkProfile
from .virtual_machine_scale_set_extension import VirtualMachineScaleSetExtension
from .virtual_machine_scale_set_extension_profile import VirtualMachineScaleSetExtensionProfile
from .virtual_machine_scale_set_vm_profile import VirtualMachineScaleSetVMProfile
from .virtual_machine_scale_set import VirtualMachineScaleSet
from .virtual_machine_scale_set_vm_instance_ids import VirtualMachineScaleSetVMInstanceIDs
from .virtual_machine_scale_set_vm_instance_required_ids import VirtualMachineScaleSetVMInstanceRequiredIDs
from .virtual_machine_status_code_count import VirtualMachineStatusCodeCount
from .virtual_machine_scale_set_instance_view_statuses_summary import VirtualMachineScaleSetInstanceViewStatusesSummary
from .virtual_machine_scale_set_vm_extensions_summary import VirtualMachineScaleSetVMExtensionsSummary
from .virtual_machine_scale_set_instance_view import VirtualMachineScaleSetInstanceView
from .virtual_machine_scale_set_sku_capacity import VirtualMachineScaleSetSkuCapacity
from .virtual_machine_scale_set_sku import VirtualMachineScaleSetSku
from .virtual_machine_scale_set_vm import VirtualMachineScaleSetVM
from .virtual_machine_scale_set_vm_instance_view import VirtualMachineScaleSetVMInstanceView
from .api_error_base import ApiErrorBase
from .inner_error import InnerError
from .api_error import ApiError
from .compute_long_running_operation_properties import ComputeLongRunningOperationProperties
from .resource import Resource
from .sub_resource_read_only import SubResourceReadOnly
from .operation_status_response import OperationStatusResponse
from .resource_update import ResourceUpdate
from .image_disk_reference import ImageDiskReference
from .creation_data import CreationData
from .source_vault import SourceVault
from .key_vault_and_secret_reference import KeyVaultAndSecretReference
from .key_vault_and_key_reference import KeyVaultAndKeyReference
from .encryption_settings import EncryptionSettings
from .disk import Disk
from .disk_update import DiskUpdate
from .grant_access_data import GrantAccessData
from .access_uri import AccessUri
from .snapshot import Snapshot
from .snapshot_update import SnapshotUpdate
from .availability_set_paged import AvailabilitySetPaged
from .virtual_machine_size_paged import VirtualMachineSizePaged
from .usage_paged import UsagePaged
from .image_paged import ImagePaged
from .virtual_machine_paged import VirtualMachinePaged
from .virtual_machine_scale_set_paged import VirtualMachineScaleSetPaged
from .virtual_machine_scale_set_sku_paged import VirtualMachineScaleSetSkuPaged
from .virtual_machine_scale_set_vm_paged import VirtualMachineScaleSetVMPaged
from .disk_paged import DiskPaged
from .snapshot_paged import SnapshotPaged
from .compute_management_client_enums import (
    StatusLevelTypes,
    OperatingSystemTypes,
    VirtualMachineSizeTypes,
    CachingTypes,
    DiskCreateOptionTypes,
    StorageAccountTypes,
    PassNames,
    ComponentNames,
    SettingNames,
    ProtocolTypes,
    ResourceIdentityType,
    UpgradeMode,
    OperatingSystemStateTypes,
    VirtualMachineScaleSetSkuScaleType,
    DiskCreateOption,
    AccessLevel,
    InstanceViewTypes,
)

__all__ = [
    'InstanceViewStatus',
    'SubResource',
    'Sku',
    'AvailabilitySet',
    'VirtualMachineSize',
    'VirtualMachineExtensionImage',
    'VirtualMachineImageResource',
    'VirtualMachineExtensionInstanceView',
    'VirtualMachineExtension',
    'PurchasePlan',
    'OSDiskImage',
    'DataDiskImage',
    'VirtualMachineImage',
    'UsageName',
    'Usage',
    'VirtualMachineCaptureParameters',
    'VirtualMachineCaptureResult',
    'Plan',
    'HardwareProfile',
    'ImageReference',
    'KeyVaultSecretReference',
    'KeyVaultKeyReference',
    'DiskEncryptionSettings',
    'VirtualHardDisk',
    'ManagedDiskParameters',
    'OSDisk',
    'DataDisk',
    'StorageProfile',
    'AdditionalUnattendContent',
    'WinRMListener',
    'WinRMConfiguration',
    'WindowsConfiguration',
    'SshPublicKey',
    'SshConfiguration',
    'LinuxConfiguration',
    'VaultCertificate',
    'VaultSecretGroup',
    'OSProfile',
    'NetworkInterfaceReference',
    'NetworkProfile',
    'BootDiagnostics',
    'DiagnosticsProfile',
    'VirtualMachineExtensionHandlerInstanceView',
    'VirtualMachineAgentInstanceView',
    'DiskInstanceView',
    'BootDiagnosticsInstanceView',
    'VirtualMachineIdentity',
    'VirtualMachineInstanceView',
    'VirtualMachine',
    'UpgradePolicy',
    'ImageOSDisk',
    'ImageDataDisk',
    'ImageStorageProfile',
    'Image',
    'VirtualMachineScaleSetIdentity',
    'VirtualMachineScaleSetOSProfile',
    'VirtualMachineScaleSetManagedDiskParameters',
    'VirtualMachineScaleSetOSDisk',
    'VirtualMachineScaleSetDataDisk',
    'VirtualMachineScaleSetStorageProfile',
    'ApiEntityReference',
    'VirtualMachineScaleSetIPConfiguration',
    'VirtualMachineScaleSetNetworkConfiguration',
    'VirtualMachineScaleSetNetworkProfile',
    'VirtualMachineScaleSetExtension',
    'VirtualMachineScaleSetExtensionProfile',
    'VirtualMachineScaleSetVMProfile',
    'VirtualMachineScaleSet',
    'VirtualMachineScaleSetVMInstanceIDs',
    'VirtualMachineScaleSetVMInstanceRequiredIDs',
    'VirtualMachineStatusCodeCount',
    'VirtualMachineScaleSetInstanceViewStatusesSummary',
    'VirtualMachineScaleSetVMExtensionsSummary',
    'VirtualMachineScaleSetInstanceView',
    'VirtualMachineScaleSetSkuCapacity',
    'VirtualMachineScaleSetSku',
    'VirtualMachineScaleSetVM',
    'VirtualMachineScaleSetVMInstanceView',
    'ApiErrorBase',
    'InnerError',
    'ApiError',
    'ComputeLongRunningOperationProperties',
    'Resource',
    'SubResourceReadOnly',
    'OperationStatusResponse',
    'ResourceUpdate',
    'ImageDiskReference',
    'CreationData',
    'SourceVault',
    'KeyVaultAndSecretReference',
    'KeyVaultAndKeyReference',
    'EncryptionSettings',
    'Disk',
    'DiskUpdate',
    'GrantAccessData',
    'AccessUri',
    'Snapshot',
    'SnapshotUpdate',
    'AvailabilitySetPaged',
    'VirtualMachineSizePaged',
    'UsagePaged',
    'ImagePaged',
    'VirtualMachinePaged',
    'VirtualMachineScaleSetPaged',
    'VirtualMachineScaleSetSkuPaged',
    'VirtualMachineScaleSetVMPaged',
    'DiskPaged',
    'SnapshotPaged',
    'StatusLevelTypes',
    'OperatingSystemTypes',
    'VirtualMachineSizeTypes',
    'CachingTypes',
    'DiskCreateOptionTypes',
    'StorageAccountTypes',
    'PassNames',
    'ComponentNames',
    'SettingNames',
    'ProtocolTypes',
    'ResourceIdentityType',
    'UpgradeMode',
    'OperatingSystemStateTypes',
    'VirtualMachineScaleSetSkuScaleType',
    'DiskCreateOption',
    'AccessLevel',
    'InstanceViewTypes',
]


text:
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using Umbraco.Core;
using Umbraco.Web.Models.Trees;
using Umbraco.Web.WebApi.Filters;

namespace Umbraco.Web.Trees
{
    [CoreTree(TreeGroup = Constants.Trees.Groups.Settings)]
    [UmbracoTreeAuthorize(Constants.Trees.MemberTypes)]
    [Tree(Constants.Applications.Settings, Constants.Trees.MemberTypes, null, sortOrder: 2)]
    public class MemberTypeTreeController : MemberTypeAndGroupTreeControllerBase
    {
        protected override TreeNode CreateRootNode(FormDataCollection queryStrings)
        {
            var root = base.CreateRootNode(queryStrings);
            //check if there are any member types
            root.HasChildren = Services.MemberTypeService.GetAll().Any();
            return root;
        }
        protected override IEnumerable<TreeNode> GetTreeNodesFromService(string id, FormDataCollection queryStrings)
        {
            return Services.MemberTypeService.GetAll()
                .OrderBy(x => x.Name)
                .Select(dt => CreateTreeNode(dt, Constants.ObjectTypes.MemberType, id, queryStrings, "icon-item-arrangement", false));
        }
    }
}


text:
const request = require('supertest');
const express = require('express');
var dotenv = require('dotenv');
dotenv.config()
var app = 'localhost:'+process.env.LOCALHOSTPORT
describe('SIGNOUT signout', function() {
  it('200', function(done) {
    request(app)
    .get('/signout').then(response => {
      expect(response.statusCode).toBe(302)
      done();
    });
  });
});


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author kejij
 */
import java.io.*;
import static java.lang.Double.parseDouble;
import static java.lang.Integer.parseInt;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

public class DumpParser {
    private static double length = 0.0;  // Ticks
    private static double res = 0.0;  // Ticks per beat
    private static double bpm = 0.0;  // Beats per minute
    private static double tps = 0.0;  // Ticks per second
    private static double delay = 0d;  // Delay for the song
    private static TreeMap beatmap = new TreeMap();

    public static void main (String[] args) {
        String fileName = "chainsmokers-dump.txt";
        String line = null;  // Stores the info in each line
        try {
            // FileReader reads text files in the default encoding.
            FileReader fileReader = new FileReader(fileName);

            // Always wrap FileReader in BufferedReader.
            BufferedReader bufferedReader = new BufferedReader(fileReader);

            // The dump file must contain each string sequentially
            while((line = bufferedReader.readLine()) != null) {
                if (line.contains("Length")) {
                    length = parseDouble(line.substring(8, 14));
                    continue;
                }
                if (line.contains("Resolution")) {
                    res = parseDouble(line.substring(12, 15));
                    continue;
                }
                if (line.contains("Tempo:")) {
                    bpm = parseDouble(line.substring(19, 23));
                    tps = res * bpm / 60;
                    continue;
                }
                // Parse in noteOn events with non-zero velocity
                if (line.contains("note On") && !line.contains("velocity: 0")) {
                    // Get the tick indices
                    int tickEnd = line.indexOf(": [");
                    int tickNum = parseInt(line.substring(5, tickEnd));

                    // Convert ticks to seconds and round to third decimal
                    double seconds = (double) (tickNum / tps);
                    double time = Math.round((seconds - delay) * 1000d) / 1000d;
                    // Get the note indexes if necessary
                    // int noteStart = line.indexOf("note On") + 8;
                    // int noteEnd = line.indexOf("velocity");

                    // Get a random beat
                    String beats = getBeats();

                    // Add time and beat information to hashmap
                    if (!beatmap.containsKey(time)) {
                        beatmap.put(time, beats);
                    }
                }
            }

            // Print contents of the Hashmap
            Iterator it = beatmap.entrySet().iterator();
            while(it.hasNext()) {
                Map.Entry pair = (Map.Entry) it.next();
                out("    {song_pos: " + pair.getKey() + ", beats: \"" +
                        pair.getValue() + "\"},");
                it.remove();
            }

            bufferedReader.close();  // End File IO
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    //
    private static String getBeats() {
        // Beats for the note
        char[] ret = "000000".toCharArray();

        // Randomize the beats to set to play
        int firstBeat = (int) (Math.random() * 6);
        //int secondBeat = (int) (Math.random() * 6);
        ret[firstBeat] = '1';
        //ret[secondBeat] = '1';
        return new String(ret);
    }

    // Wrapper methods for printing outputs
    private static void out(String strMessage) {
            System.out.println(strMessage);
    }
    private static void out(Double d) {
            System.out.println(d);
    }
    private static void out(int i) {
            System.out.println(i);
    }
}


text:
title:  Kasırganın İçinden
date:   04/12/2016
---

### Kasırganın İçinden
`Eyüp 38:1 ayetini oku. Burada tüm diğer konuşmalardan farklı olarak ne oluyor?`

Aniden ve beklenmedik bir şekilde, Eyüp 2:6 (Rab, "Peki" dedi, "Onu senin eline bırakıyorum. Yalnız canına dokunma") ayetinden beri ilk kez, Rab Eyüp kitapçığında ortaya çıkıyor.

Okuyucuyu Allah'ın bu aniden ortaya çıkışına hazırlayan hiçbir şey yok. Eyüp 37. bölüm Elihu'nun konuşmasıyla bitiyor, bundan hemen sonra okuduğumuz ise "Rab kasırganın içinden Eyüp'ü şöyle yanıtladı" (Eyüp 38:1). Bir anda, sanki diğer adamlar konu dışındaymış gibi, sah- nede sadece Allah ve Eyüp var, en azından şimdilik.

Kasırga olarak çevrilen sözcük "fırtına" veya "bora" anlamındaki İbranice bir sözcükten gelir ve Allah'ın insanlara görünüşüyle bağlan- tılı olarak kullanılmıştır (bkz. Yşa. 29:6, Zek. 9:14). Bu aynı zamanda İlyas'ın göğe alınışı bağlamında kullanılan sözcüktür: "Rab İlyas'ı kasırgayla göklere çıkarmadan önce, İlyas ile Elişa Gilgal'dan ayrılıp yola çıkmışlardı" (2Kr. 2:1).

Her ne kadar bu "teofani" (Tanrı'nın insanlara görünür şekilde teza- hür etmesi) hakkında fiziksel ayrıntılar verilmese de, Allah'ın Eyüp'le "ince, yumuşak bir ses"le (1Kr. 19:12) konuşmadığı açık. Aksine, Rab çok güçlü bir şekilde, kesinlikle Eyüp'ün ilgisini çeken bir şekilde Kendisini göstermişti.

Tabi ki bu Allah'ın düşmüş insanlığa Kendisini ilk gösterişi değildi. Kutsal Yazılar tekrar tekrar bize Allah'ın insanlara yakınlığını gösteriyor.

Aşağıdaki ayetler Allah'ın bize ne kadar yakın olabileceği konusunda ne öğretiyor? Yar. 15:1–6, Yar. 32:24–32, Yu. 1:29.

Kutsal Kitap bize Allah'ın dünyamızı yaratıp bizi kendi halimize bırakan, bizden uzak bir Tanrı olmadığı büyük ve önemli gerçeğini öğretiyor. Aksine, O bizimle yakın ilişkide olan bir Tanrı'dır. Acılarımız ve sıkıntılarımız ne olursa olsun, bu hayatta neyle karşılaşmış olursak olalım, Allah'ın yakında olduğu ve O'na itimat edebileceğimiz güven- cesine sahibiz.

`Allah'ın bize yakınlığına akıl ile inanmak bir şey; bu yakınlığı tecrübe etmek çok başka bir şey. Allah'a daha yakın olmayı ve bu ilişkiden umut ve rahatlık çıkarmayı nasıl öğrenebilirsin?`


text:
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

IMPLEMENT_SERIAL (CBCGToolbarRegularMenuButton, CBCGToolbarMenuButton, VERSIONABLE_SCHEMA | 1)

BOOL CBCGToolbarRegularMenuButton::OnClick(CWnd* pWnd, BOOL bDelay)
{
	// Standardverarbeitung
	CBCGToolbarMenuButton::OnClick(pWnd, bDelay);

	if (CBCGToolBar::IsCustomizeMode())
		return FALSE;

	CPoint ptPos;

	if (m_bHorz)
	{
		ptPos.x = m_rect.left;
		ptPos.y = m_rect.bottom;
	}

	else
	{
		ptPos.x = m_rect.right;
		ptPos.y = m_rect.top;
	}

	CWnd* pParent = m_pWndParent == NULL ?
						AfxGetMainWnd () :
						BCGGetTopLevelFrame (m_pWndParent);
	pParent->ClientToScreen(&ptPos);

	pParent->SendMessage(BCGM_SHOWREGULARMENU, m_nID, MAKELONG(ptPos.x, ptPos.y));
	return TRUE;
}


text:
pub mod html;
pub mod js;
pub mod page_data;
pub mod page_templates;

pub use self::html::*;
pub use self::js::*;
pub use self::page_data::*;
pub use self::page_templates::*;

use isymtope_ast_common::*;

#[derive(Debug)]
pub struct  ActionOpOutput<T>(pub Option<String>, pub ActionOp<T>);

#[derive(Debug)]
pub struct ElementEventBindingOutput<T>(pub Option<String>, String, pub ObjectValue<T>);

impl<'a> Into<ElementEventBindingOutput<ProcessedExpression>> for &'a ElementEventBindingName<ProcessedExpression> {
    fn into(self) -> ElementEventBindingOutput<ProcessedExpression> {
        let event = self.event();
        let name = event.name().map(|s| s.to_owned());
        let key = self.key().to_owned();

        let actions: Vec<_> = event
            .actions()
            .map(|v| v.into_iter().collect())
            .unwrap_or_default();
        eprintln!("Event actions: {:?}", &actions);

        let action_props: ObjectValue<ProcessedExpression> = actions
            .into_iter()
            .enumerate()
            .flat_map(|(ctr, action)| {
                let key = format!("a{}", ctr);
                let prop = match *action {
                    ActionOp::DispatchAction(_, Some(box ref props), _)
                    | ActionOp::DispatchActionTo(_, Some(box ref props), _, _) => {
                        let props: ObjectValue<ProcessedExpression> = props.iter().cloned().collect();
                        Some(PropValue::new(key, props.into(), None))
                    }
                    ActionOp::Navigate(ref path, _) => {
                        // let props: ObjectValue<ProcessedExpression> = vec!["path".to_owned(), path.to_owned(), None)].into_iter().collect();
                        Some(PropValue::new(key, path.to_owned(), None))
                    }
                    _ => None
                };
                prop
            })
            .collect();

        ElementEventBindingOutput(name, key, action_props)
    }
}


text:
package nmea

import "strings"

const (
	// TypeDSC type of DSC sentence for Digital Selective Calling Information
	TypeDSC = "DSC"

	// AcknowledgementRequestDSC is type for Acknowledge request
	AcknowledgementRequestDSC = "R"
	// AcknowledgementDSC is type for Acknowledgement
	AcknowledgementDSC = "B"
	// AcknowledgementNeitherDSC is type for Neither (end of sequence)
	AcknowledgementNeitherDSC = "S"
)

// DSC – Digital Selective Calling Information
// https://opencpn.org/wiki/dokuwiki/doku.php?id=opencpn:opencpn_user_manual:advanced_features:nmea_sentences
// https://web.archive.org/web/20190303170916/http://continuouswave.com/whaler/reference/DSC_Datagrams.html
// http://www.busse-yachtshop.de/pdf/icom-GM600-handbuch.pdf
// https://github.com/mariokonrad/marnav/blob/master/src/marnav/nmea/dsc.cpp (marnav has interesting enums worth checking)
//
// Note: many fields of DSC are conditional with double meaning and we only map raw sentence to fields without any
// logic/checking of those conditions. We could have specific fields if we only knew the rules to populate them.
//
// Format: $--DSC,xx,xxxxxxxxxx,xx,xx,xx,x.x, x.x,xxxxxxxxxx,xx, a,a*hh<CR><LF>
// Example: $CDDSC,20,3380400790,00,21,26,1423108312,2021,,,B, E*73
type DSC struct {
	BaseSentence
	// Note: all fields are strings even if specified as digits as int can not express "00" and would be 0 which is different
	// Source of quotes: https://web.archive.org/web/20190303170916/http://continuouswave.com/whaler/reference/DSC_Datagrams.html

	// FormatSpecifier is Format specifier (2 digits)
	// > The call content is first described by a "format specifier" element. The format specifier is explained in
	// > ITU-Rec. M.493-13 Section 4, with various symbol codes in the "service command" range of symbols representing
	// > various message formats, as shown in Table 3 (by symbol number, then meaning of symbol) as follows:
	// > * 102 = selective call to a group of ships in particular geographic area
	// > * 112 = distress alert call
	// > * 114 = selective call to a group of ships having common interest
	// > * 116 = all ships call
	// > * 120 = selective call to particular individual station
	// > * 123 = selective call to a particular individual using automatic service
	FormatSpecifier string

	// Address (10 digits)
	Address string

	// Category (2 digits or empty)
	// > The call content is next described by a "category element" in Section 6. Again, various symbol codes in the
	// > "service command" range of symbols represent various categories, as follows from Table 3 (by symbol number,
	// > then meaning of symbol):
	// > * 100 = routine
	// > * 108 = safety
	// > * 110 = urgency
	// > * 112 = distress
	Category string

	// DistressCauseOrTeleCommand1 is The cause of the distress or first telecommand (2 digits or empty)
	// > Nature of Distress is to be encoded, again using Table 3, as follows
	// > * 100 = Fire, explosion
	// > * 101 = Flooding
	// > * 102 = Collision
	// > * 103 = Grounding
	// > * 104 = Listing, in danger of capsize
	// > * 105 = Sinking
	// > * 106 = Disabled and adrift
	// > * 107 = Undesignated distres
	// > * 108 = Abandoning ship
	// > * 109 = Piracy/armed robbery attack
	// > * 110 = Man overboard
	// > * 111 = unassigned symbol; take no action
	// > * 112 = EPRIB emission
	// > * 113 through 27 = unassigned symbol; take no action
	DistressCauseOrTeleCommand1 string

	// CommandTypeOrTeleCommand2 is Type of communication or second telecommand (2 digits)
	CommandTypeOrTeleCommand2 string

	// PositionOrCanal is Position (lat+lon) or Canal/frequency (Maximum 16 digits)
	// > Distress coordinates are to be encoded five parts, sent as a string of ten digits. The first digit indicates
	// > the direction of the latitude and longitude, with "0" for North and East, "1" for North and West,
	// > "2" for South and East, and "3" for South and West. The next two digits are the latitude in degrees.
	// > The next two digits are the latitude in whole minutes. The next three digits are the longitude in degrees.
	// > The next two digits are longitude in whole minutes.
	PositionOrCanal string // Position (lat+lon) or Canal/frequency (Maximum 16 digits)

	// TimeOrTelephoneNumber is Time or Telephone Number (Maximum 16 digits)
	// > The time in universal coordinated time is to be sent in 24-hour format in two parts, a total of four digits.
	// > The first two digits are the hours. The next two are the minutes.
	TimeOrTelephoneNumber string

	// MMSI of ship in distress (10 digits or empty)
	// > The call content is next described as having a "self-identification" element. This is simply the sending
	// > station's MMSI, encoded like the address element. This identifies who sent the message.
	MMSI string

	// DistressCause is The cause of the distress (2 digits or empty)
	DistressCause string

	// Acknowledgement (R=Acknowledge request, B=Acknowledgement, S=Neither (end of sequence))
	Acknowledgement string

	// Expansion indicator (E or empty)
	ExpansionIndicator string
}

// newDSC constructor
func newDSC(s BaseSentence) (DSC, error) {
	p := NewParser(s)
	p.AssertType(TypeDSC)
	return DSC{
		BaseSentence:                s,
		FormatSpecifier:             p.String(0, "format specifier"),
		Address:                     p.String(1, "address"),
		Category:                    p.String(2, "category"),
		DistressCauseOrTeleCommand1: p.String(3, "cause of the distress or first telecommand"),
		CommandTypeOrTeleCommand2:   p.String(4, "type of communication or second telecommand"),
		PositionOrCanal:             p.String(5, "position or canal"),
		TimeOrTelephoneNumber:       p.String(6, "time or telephone"),
		MMSI:                        p.String(7, "MMSI"),
		DistressCause:               p.String(8, "distress cause"),
		Acknowledgement: strings.TrimSpace(p.EnumString(
			9,
			"acknowledgement",
			AcknowledgementRequestDSC,
			" "+AcknowledgementRequestDSC,
			AcknowledgementDSC,
			" "+AcknowledgementDSC,
			AcknowledgementNeitherDSC,
			" "+AcknowledgementNeitherDSC,
		)),
		ExpansionIndicator: p.String(10, "expansion indicator"),
	}, p.Err()
}


text:
namespace _04.SplitByWord
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    public class SplitByWord
    {
        public static void Main()
        {
            String inputText = Console.ReadLine();
            string[] words = inputText
                                .Split(new char[] { ',', '.', ';', ':', '!', '(', ')', '"', '\'', '\\', '/', '[', ']', ' ' },
                                StringSplitOptions.RemoveEmptyEntries);

            List<string> lowerCase = new List<string>();
            List<string> upperCase = new List<string>();
            List<string> mixedCase = new List<string>();

            for (int i = 0; i < words.Length; i++)
            {
                string upCase = words[i].ToUpper();
                string lowCase = words[i].ToLower();
                if (words[i].Equals(upCase) && !CheckForSymbols(words[i]))
                {
                    upperCase.Add(words[i]);
                }
                else if (words[i].Equals(lowCase) && !CheckForSymbols(words[i]))
                {
                    lowerCase.Add(words[i]);
                }
                else
                {
                    mixedCase.Add(words[i]);
                }
            }
            Console.WriteLine();

            Console.Write("Lower-case: ");
            Console.WriteLine(string.Join(", ", lowerCase));
            Console.Write("Mixed-case: ");
            Console.WriteLine(string.Join(", ", mixedCase));
            Console.Write("Upper-case: ");
            Console.WriteLine(string.Join(", ", upperCase));

        }
        private static bool CheckForSymbols(string word)
        {
            char[] symbols = word.ToCharArray();
            for (int i = 0; i < word.Length; i++)
            {
                if ((int)symbols[i] < 65)
                {
                    return true;
                }
            }

            return false;
        }
    }
}


text:
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Tesseract.Tests.Console")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Tesseract.Tests.Console")]
[assembly: AssemblyCopyright("Copyright ©  2013")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible
// to COM components.  If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("38fc73b0-827c-45ec-b5aa-e8f623c80d40")]

// Versioning is handled by AssemblyVersionInfo.cs


text:
(function(angular, undefined) {
  'use strict';

  // src/js/helper.module.js
  var fontselectModule = angular.module('jdFontselect', []);

  // src/js/helper.defaults.js
  /** @const */
  var PROVIDER_WEBSAFE = 'Websafe Fonts';

  /** @const */
  var PROVIDER_GOOGLE = 'Google Fonts';

  /** @const */
  var PROVIDERS = [
    PROVIDER_WEBSAFE,
    PROVIDER_GOOGLE
  ];

  /** @const */
  var NAME_CONTROLLER = '.controller';

  /** @const */
  var NAME_FONTSSERVICE = 'jdFontselect.fonts';

  /** @const */
  var DEFAULT_WEBSAFE_FONTS = [
    {
      name: 'Arial',
      key: 'arial',
      category: 'sansserif',
      stack: 'Arial, "Helvetica Neue", Helvetica, sans-serif',
      popularity: 3,
      lastModified: '2014-01-28'
    },
    {
      name: 'Consolas',
      key: 'consolas',
      category: 'other',
      stack: 'Consolas, "Lucida Console", Monaco, monospace',
      popularity: 1,
      lastModified: '2014-02-04'
    },
    {
      name: 'Courier New',
      key: 'couriernew',
      category: 'other',
      stack: '"Courier New", Courier, "Lucida Sans Typewriter", "Lucida Typewriter", monospace',
      popularity: 1,
      lastModified: '2014-01-28'
    },
    {
      name: 'Georgia',
      key: 'georgia',
      category: 'serif',
      stack: 'Georgia, Palatino, "Palatino Linotype", Times, "Times New Roman", serif',
      popularity: 2,
      lastModified: '2014-02-04'
    },
    {
      name: 'Helvetica',
      key: 'helvetica',
      category: 'sansserif',
      stack: 'Helvetica, "Helvetica Neue", Arial, sans-serif',
      popularity: 3,
      lastModified: '2014-02-04'
    },
    {
      name: 'Impact',
      key: 'impact',
      category: 'other',
      stack: 'Impact, Haettenschweiler, "Arial Narrow Bold", sans-serif',
      popularity: 3,
      lastModified: '2014-02-04'
    },
    {
      name: 'Lucida Sans',
      key: 'lucidasans',
      category: 'sansserif',
      stack: '"Lucida Sans", "Lucida Grande", "Lucida Sans Unicode", sans-serif',
      popularity: 3,
      lastModified: '2014-02-04'
    },
    {
      name: 'Palatino',
      key: 'palatino',
      category: 'serif',
      stack: 'Palatino, "Palatino Linotype", Georgia, Times, "Times New Roman", serif',
      popularity: 2,
      lastModified: '2014-02-04'
    },
    {
      name: 'Tahoma',
      key: 'tahoma',
      category: 'sansserif',
      stack: 'Tahoma, Verdana, Geneva, sans-serif',
      popularity: 6,
      lastModified: '2014-02-04'
    },
    {
      name: 'Trebuchet',
      key: 'trebuchet',
      category: 'sansserif',
      stack: '"Trebuchet MS", "Lucida Sans Unicode", "Lucida Grande", "Lucida Sans", Arial, sans-serif',
      popularity: 6,
      lastModified: '2014-02-04'
    },
    {
      name: 'Verdana',
      key: 'verdana',
      category: 'sansserif',
      stack: 'Verdana, Geneva, sans-serif',
      popularity: 6,
      lastModified: '2014-01-28'
    },
    {
      name: 'Times New Roman',
      key: 'timesnewroman',
      category: 'serif',
      stack: 'TimesNewRoman, "Times New Roman", Times, Baskerville, Georgia, serif',
      popularity: 2,
      lastModified: '2014-01-28'
    },
    {
      name: 'Brush Script',
      key: 'brushscript',
      category: 'handwriting',
      stack: '"Brush Script MT", cursive',
      popularity: 5,
      lastModified: '2014-01-29'
    }
  ];

  fontselectModule.constant('jdFontselectConfig', {
    googleApiKey: false
  });

  // src/js/helper.google-font-categories.js
  /** @const */
  var GOOGLE_FONT_CATEGORIES = {
    'Handwriting': [
      'Patrick Hand SC',
      'Grand Hotel',
      'Calligraffitti',
      'Coming Soon',
      'Crafty Girls',
      'Homemade Apple',
      'Just Another Hand',
      'Montez',
      'Permanent Marker',
      'Rancho',
      'Redressed',
      'Rochester',
      'Rock Salt',
      'Satisfy',
      'Schoolbell',
      'Sunshiney',
      'Walter Turncoat',
      'Yellowtail',
      'Aguafina Script',
      'Aladin',
      'Alex Brush',
      'Allura',
      'Amatic SC',
      'Annie Use Your Telescope',
      'Architects Daughter',
      'Arizonia',
      'Bad Script',
      'Berkshire Swash',
      'Bilbo',
      'Bilbo Swash Caps',
      'Bonbon',
      'Butterfly Kids',
      'Cedarville Cursive',
      'Clicker Script',
      'Condiment',
      'Cookie',
      'Courgette',
      'Covered By Your Grace',
      'Damion',
      'Dancing Script',
      'Dawning of a New Day',
      'Delius',
      'Delius Swash Caps',
      'Delius Unicase',
      'Devonshire',
      'Dr Sugiyama',
      'Eagle Lake',
      'Engagement',
      'Euphoria Script',
      'Felipa',
      'Fondamento',
      'Give You Glory',
      'Gloria Hallelujah',
      'Gochi Hand',
      'Great Vibes',
      'Handlee',
      'Herr Von Muellerhoff',
      'Indie Flower',
      'Italianno',
      'Jim Nightshade',
      'Julee',
      'Just Me Again Down Here',
      'Kaushan Script',
      'Kristi',
      'La Belle Aurore',
      'League Script',
      'Leckerli One',
      'Loved by the King',
      'Lovers Quarrel',
      'Marck Script',
      'Meddon',
      'Meie Script',
      'Merienda',
      'Merienda One',
      'Mervale Script',
      'Miama',
      'Miss Fajardose',
      'Miss Saint Delafield',
      'Molle',
      'Monsieur La Doulaise',
      'Mr Bedford',
      'Mr Bedfort',
      'Mr Dafoe',
      'Mr De Haviland',
      'Mrs Saint Delafield',
      'Mrs Sheppards',
      'Neucha',
      'Niconne',
      'Norican',
      'Nothing You Could Do',
      'Over the Rainbow',
      'Pacifico',
      'Parisienne',
      'Patrick Hand',
      'Pecita',
      'Petit Formal Script',
      'Pinyon Script',
      'Princess Sofia',
      'Quintessential',
      'Qwigley',
      'Reenie Beanie',
      'Romanesco',
      'Rouge Script',
      'Ruge Boogie',
      'Ruthie',
      'Sacramento',
      'Shadows Into Light',
      'Shadows Into Light Two',
      'Short Stack',
      'Sofia',
      'Stalemate',
      'Sue Ellen Francisco',
      'Swanky and Moo Moo',
      'Tangerine',
      'The Girl Next Door',
      'Vibur',
      'Waiting for the Sunrise',
      'Yesteryear',
      'Zeyada',
      'Domine',
      'Donegal One'
    ],
    'Sans Serif': [
      'Wendy One',
      'Tauri',
      'Sintony',
      'Pathway Gothic One',
      'Noto Sans',
      'Monda',
      'Merriweather Sans',
      'Exo 2',
      'Aclonica',
      'Alef',
      'Alegreya Sans',
      'Alegreya Sans SC',
      'Denk One',
      'Droid Sans',
      'Droid Sans Mono',
      'Open Sans',
      'Open Sans Condensed',
      'Roboto',
      'Roboto Condensed',
      'Syncopate',
      'ABeeZee',
      'Abel',
      'Acme',
      'Actor',
      'Advent Pro',
      'Aldrich',
      'Allerta',
      'Allerta Stencil',
      'Amaranth',
      'Anaheim',
      'Andika',
      'Anonymous Pro',
      'Antic',
      'Anton',
      'Archivo Black',
      'Archivo Narrow',
      'Arimo',
      'Armata',
      'Asap',
      'Asul',
      'Average Sans',
      'Basic',
      'Belleza',
      'BenchNine',
      'Bubbler One',
      'Cabin',
      'Cabin Condensed',
      'Cagliostro',
      'Candal',
      'Cantarell',
      'Cantora One',
      'Capriola',
      'Carme',
      'Carrois Gothic',
      'Carrois Gothic SC',
      'Changa',
      'Chau Philomene One',
      'Chivo',
      'Coda Caption',
      'Convergence',
      'Cousine',
      'Cuprum',
      'Days One',
      'Didact Gothic',
      'Doppio One',
      'Dorsa',
      'Dosis',
      'Duru Sans',
      'Economica',
      'Electrolize',
      'Englebert',
      'Exo',
      'Federo',
      'Fjalla One',
      'Francois One',
      'Fresca',
      'Gafata',
      'Galdeano',
      'Geo',
      'Gudea',
      'Hammersmith One',
      'Hermeneus One',
      'Homenaje',
      'Imprima',
      'Inconsolata',
      'Inder',
      'Istok Web',
      'Jockey One',
      'Josefin Sans',
      'Josefin Sans Std Light',
      'Julius Sans One',
      'Jura',
      'Karla',
      'Kite One',
      'Krona One',
      'Lato',
      'Lekton',
      'Magra',
      'Mako',
      'Marmelad',
      'Marvel',
      'Maven Pro',
      'Merge One',
      'Metrophobic',
      'Michroma',
      'Molengo',
      'Montserrat',
      'Montserrat Alternates',
      'Montserrat Subrayada',
      'Mouse Memoirs',
      'Muli',
      'News Cycle',
      'Nobile',
      'Numans',
      'Nunito',
      'Orbitron',
      'Orienta',
      'Oswald',
      'Oxygen',
      'Oxygen Mono',
      'Paytone One',
      'Philosopher',
      'Play',
      'Pontano Sans',
      'Port Lligat Sans',
      'PT Mono',
      'PT Sans',
      'PT Sans Caption',
      'PT Sans Narrow',
      'Puritan',
      'Quantico',
      'Quattrocento Sans',
      'Questrial',
      'Quicksand',
      'Raleway',
      'Rambla',
      'Rationale',
      'Ropa Sans',
      'Rosario',
      'Ruda',
      'Ruluko',
      'Rum Raisin',
      'Russo One',
      'Sansation',
      'Scada',
      'Seymour One',
      'Shanti',
      'Share Tech',
      'Share Tech Mono',
      'Signika',
      'Signika Negative',
      'Six Caps',
      'Snippet',
      'Source Code Pro',
      'Source Sans Pro',
      'Spinnaker',
      'Strait',
      'Strong',
      'Telex',
      'Tenor Sans',
      'Terminal Dosis',
      'Terminal Dosis Light',
      'Text Me One',
      'Titillium Web',
      'Tuffy',
      'Varela',
      'Varela Round',
      'Viga',
      'Voltaire',
      'Wire One',
      'Yanone Kaffeesatz',
      'Ubuntu',
      'Ubuntu Condensed',
      'Ubuntu Mono'
    ],
    'Display': [
      'Vampiro One',
      'Snowburst One',
      'Purple Purse',
      'New Rocker',
      'Milonga',
      'Margarine',
      'Lily Script One',
      'Kavoon',
      'Hanalei',
      'Hanalei Fill',
      'Fruktur',
      'Freckle Face',
      'Elsie',
      'Elsie Swash Caps',
      'Cherry Cream Soda',
      'Chewy',
      'Creepster Caps',
      'Crushed',
      'Fontdiner Swanky',
      'Irish Grover',
      'Irish Growler',
      'Kranky',
      'Luckiest Guy',
      'Maiden Orange',
      'Mountains of Christmas',
      'Slackey',
      'Smokum',
      'Special Elite',
      'Unkempt',
      'Abril Fatface',
      'Akronim',
      'Alfa Slab One',
      'Allan',
      'Almendra Display',
      'Amarante',
      'Arbutus',
      'Asset',
      'Astloch',
      'Atomic Age',
      'Aubrey',
      'Audiowide',
      'Autour One',
      'Averia Gruesa Libre',
      'Averia Libre',
      'Averia Sans Libre',
      'Averia Serif Libre',
      'Bangers',
      'Baumans',
      'Bevan',
      'Bigelow Rules',
      'Bigshot One',
      'Black Ops One',
      'Boogaloo',
      'Bowlby One',
      'Bowlby One SC',
      'Bubblegum Sans',
      'Buda',
      'Butcherman',
      'Butcherman Caps',
      'Cabin Sketch',
      'Caesar Dressing',
      'Carter One',
      'Ceviche One',
      'Changa One',
      'Chango',
      'Chela One',
      'Chelsea Market',
      'Cherry Swash',
      'Chicle',
      'Cinzel Decorative',
      'Clara',
      'Coda',
      'Codystar',
      'Combo',
      'Comfortaa',
      'Concert One',
      'Contrail One',
      'Corben',
      'Creepster',
      'Croissant One',
      'Diplomata',
      'Diplomata SC',
      'Dynalight',
      'Eater',
      'Eater Caps',
      'Emblema One',
      'Emilys Candy',
      'Erica One',
      'Ewert',
      'Expletus Sans',
      'Fascinate',
      'Fascinate Inline',
      'Faster One',
      'Federant',
      'Finger Paint',
      'Flamenco',
      'Flavors',
      'Forum',
      'Fredericka the Great',
      'Fredoka One',
      'Frijole',
      'Fugaz One',
      'Galindo',
      'Geostar',
      'Geostar Fill',
      'Germania One',
      'Glass Antiqua',
      'Goblin One',
      'Gorditas',
      'Graduate',
      'Gravitas One',
      'Griffy',
      'Gruppo',
      'Happy Monkey',
      'Henny Penny',
      'Iceberg',
      'Iceland',
      'Jacques Francois Shadow',
      'Jolly Lodger',
      'Joti One',
      'Keania One',
      'Kelly Slab',
      'Kenia',
      'Knewave',
      'Lancelot',
      'Lemon',
      'Lemon One',
      'Life Savers',
      'Lilita One',
      'Limelight',
      'Lobster',
      'Lobster Two',
      'Londrina Outline',
      'Londrina Shadow',
      'Londrina Sketch',
      'Londrina Solid',
      'Love Ya Like A Sister',
      'Macondo',
      'Macondo Swash Caps',
      'McLaren',
      'MedievalSharp',
      'Medula One',
      'Megrim',
      'Metal Mania',
      'Metamorphous',
      'Miltonian',
      'Miltonian Tattoo',
      'Miniver',
      'Modern Antiqua',
      'Monofett',
      'Monoton',
      'Mystery Quest',
      'Nixie One',
      'Nosifer',
      'Nosifer Caps',
      'Nova Cut',
      'Nova Flat',
      'Nova Mono',
      'Nova Oval',
      'Nova Round',
      'Nova Script',
      'Nova Slim',
      'Nova Square',
      'Offside',
      'Oldenburg',
      'Oleo Script',
      'Oleo Script Swash Caps',
      'Oregano',
      'Original Surfer',
      'Overlock',
      'Overlock SC',
      'Paprika',
      'Passero One',
      'Passion One',
      'Patua One',
      'Peralta',
      'Piedra',
      'Pirata One',
      'Plaster',
      'Playball',
      'Poetsen One',
      'Poiret One',
      'Poller One',
      'Pompiere',
      'Press Start 2P',
      'Prosto One',
      'Racing Sans One',
      'Raleway Dots',
      'Rammetto One',
      'Ranchers',
      'Revalia',
      'Ribeye',
      'Ribeye Marrow',
      'Righteous',
      'Risque',
      'Ruslan Display',
      'Rye',
      'Sail',
      'Salsa',
      'Sancreek',
      'Sansita One',
      'Sarina',
      'Seaweed Script',
      'Sevillana',
      'Share',
      'Shojumaru',
      'Sigmar One',
      'Simonetta',
      'Sirin Stencil',
      'Skranji',
      'Smythe',
      'Sniglet',
      'Sofadi One',
      'Sonsie One',
      'Spicy Rice',
      'Spirax',
      'Squada One',
      'Stalinist One',
      'Stalin One',
      'Stardos Stencil',
      'Stint Ultra Condensed',
      'Stint Ultra Expanded',
      'Supermercado One',
      'Titan One',
      'Trade Winds',
      'Trochut',
      'Tulpen One',
      'Uncial Antiqua',
      'Underdog',
      'Unica One',
      'UnifrakturCook',
      'UnifrakturMaguntia',
      'Unlock',
      'Vast Shadow',
      'Voces',
      'VT323',
      'Wallpoet',
      'Warnes',
      'Wellfleet',
      'Yeseva One'
    ],
    'Serif': [
      'Roboto Slab',
      'Noto Serif',
      'Libre Baskerville',
      'Gabriela',
      'Fauna One',
      'Droid Serif',
      'jsMath cmbx10',
      'jsMath cmex10',
      'jsMath cmmi10',
      'jsMath cmr10',
      'jsMath cmsy10',
      'jsMath cmti10',
      'Ultra',
      'Adamina',
      'Alegreya',
      'Alegreya SC',
      'Alice',
      'Alike',
      'Alike Angular',
      'Almendra',
      'Almendra SC',
      'Amethysta',
      'Amiri',
      'Andada',
      'Andada SC',
      'Antic Didone',
      'Antic Slab',
      'Arapey',
      'Arbutus Slab',
      'Artifika',
      'Arvo',
      'Average',
      'Balthazar',
      'Belgrano',
      'Bentham',
      'Bitter',
      'Brawler',
      'Bree Serif',
      'Buenard',
      'Cambo',
      'Cantata One',
      'Cardo',
      'Caudex',
      'Cinzel',
      'Copse',
      'Coustard',
      'Crete Round',
      'Crimson Text',
      'Cutive',
      'Cutive Mono',
      'Della Respira',
      'EB Garamond',
      'Enriqueta',
      'Esteban',
      'Fanwood Text',
      'Fenix',
      'Fjord One',
      'Gentium Basic',
      'Gentium Book Basic',
      'Gilda Display',
      'Glegoo',
      'Goudy Bookletter 1911',
      'Habibi',
      'Headland One',
      'Holtwood One SC',
      'IM Fell Double Pica',
      'IM Fell Double Pica SC',
      'IM Fell DW Pica',
      'IM Fell DW Pica SC',
      'IM Fell English',
      'IM Fell English SC',
      'IM Fell French Canon',
      'IM Fell French Canon SC',
      'IM Fell Great Primer',
      'IM Fell Great Primer SC',
      'Inika',
      'Italiana',
      'Jacques Francois',
      'Josefin Slab',
      'Judson',
      'Junge',
      'Kameron',
      'Kotta One',
      'Kreon',
      'Ledger',
      'Linden Hill',
      'Lora',
      'Lusitana',
      'Lustria',
      'Marcellus',
      'Marcellus SC',
      'Marko One',
      'Mate',
      'Mate SC',
      'Merriweather',
      'Montaga',
      'Neuton',
      'Noticia Text',
      'OFL Sorts Mill Goudy TT',
      'Old Standard TT',
      'Oranienbaum',
      'Ovo',
      'Petrona',
      'Playfair Display',
      'Playfair Display SC',
      'Podkova',
      'Poly',
      'Port Lligat Slab',
      'Prata',
      'Prociono',
      'PT Serif',
      'PT Serif Caption',
      'Quando',
      'Quattrocento',
      'Radley',
      'Rokkitt',
      'Rosarivo',
      'Rufina',
      'Sanchez',
      'Sedan',
      'Sedan SC',
      'Sorts Mill Goudy',
      'Stoke',
      'Tienne',
      'Tinos',
      'Trocchi',
      'Trykker',
      'Unna',
      'Vidaloka',
      'Volkhov',
      'Vollkorn'
    ],
    'Other': [
      'Angkor',
      'Battambang',
      'Bayon',
      'Bokor',
      'Chenla',
      'Content',
      'Dangrek',
      'Fasthand',
      'Freehand',
      'GFS Didot',
      'GFS Neohellenic',
      'Hanuman',
      'Kantumruy',
      'Kdam Thmor',
      'Khmer',
      'Koulen',
      'Metal',
      'Moul',
      'Moulpali',
      'Nokora',
      'Odor Mean Chey',
      'Preahvihear',
      'Siemreap',
      'Suwannaphum',
      'Taprom'
    ]
  };

  // src/js/helper.functions.js
  function _createKey(name) {
    return name.toLowerCase().replace(/[^a-z]+/g, '-');
  }

  // src/js/filter.start-from.js
  /* From: http://tech.small-improvements.com/2013/09/10/angularjs-performance-with-large-lists/ */
  fontselectModule.filter('startFrom', function() {
    return function(input, start) {
      if (!angular.isArray(input)) {
        return input;
      }

      return input.slice(start);
    };
  });

  // src/js/filter.fuzzy-search.js
  /**
   * Fuzzy search filter for angular.
   * Remove all entries from list that do not contain the
   * characters of our search (in the right sequence)
   *
   * Allow a configurable amount of typos (default: 1)
   *
   * @author Tim Sebastian <tim.sebastian@jimdo.com>
   * @author Hannes Diercks <hannes.diercks@jimdo.com>
   */
  fontselectModule.filter('fuzzySearch', function() {
    /** @const */
    var DEFAULTS = {
      teAmount: 0,
      tePercent: 0.3
    };

    return function(inputs, search, options) {
      if (!angular.isArray(inputs) || angular.isUndefined(search)) {
        return inputs;
      }

      var strict = true;
      var searches = [];

      options = angular.extend(DEFAULTS, options);

      function getRegex(str) {
        return new RegExp(str.replace(/./g, function(i) {return '([^' + i + ']*?(?:' + i + '))?'; }),'i');
      }

      var filter = function(input, matcher, length) {
        var matches = (input.match(matcher)||[]).filter(function(match, i) { return i !== 0 && match; });

        var errorAmountIsOk = (matches.length + options.teAmount) >= length;
        var errorPercentageIsOk = matches.length / length >= 1 - options.tePercent;

        return errorAmountIsOk || errorPercentageIsOk;
      };

      if (angular.isString(search)) {
        var rgx = getRegex(search);

        strict = false;

        angular.forEach(inputs[0], function(val, key) {
          if (key.substring(0, 1) === '$') {
            return;
          }
          searches.push({
            key: key,
            search: rgx,
            length: search.length
          });
        });
      } else if (angular.isObject(search)) {
        var valid = false;
        angular.forEach(search, function(s, k) {
          if (angular.isUndefined(s)) {
            return;
          }
          valid = true;
          searches.push({
            key: k,
            search: getRegex(s),
            length: s.length
          });
        });

        if (!valid) {
          return inputs;
        }
      }

      inputs = inputs.filter(function(input) {
        for (var i = 0, l = searches.length; i < l; i++) {
          var src = searches[i],
              searchVal = input[src.key] || '',
              ok = filter(searchVal, src.search, src.length);

          if (strict && !ok) {
            return false;
          } else if(ok) {
            return true;
          }
        }

        return false;
      });

      return inputs;
    };
  });

  // src/js/filter.has-all-subsets.js
  fontselectModule.filter('hasAllSubsets', function() {
    return function(input, subsets) {
      if (!angular.isArray(input)) {
        return input;
      }

      function hasAllSubsets(font) {
        var allOK = true;

        angular.forEach(subsets, function(active, key) {
          if (!active || !allOK) {
            return;
          }

          if (font.subsets.indexOf(key) < 0) {
            allOK = false;
          }
        });

        return allOK;
      }

      return input.filter(function(font) {
        if (angular.isUndefined(font.subsets)) {
          // TODO: ERROR
          // console.error('Font ' + font.name + ' is missing subset information.');
          return true;
        }

        return angular.isObject(font) && hasAllSubsets(font);
      });
    };
  });

  // src/js/service.fonts.js
  /** @const */
  var REQUIRED_FONT_OBJECT_KEYS = [
    'name',
    'key',
    'stack'
  ];

  /** @const */
  var SUPPORT_KHMER = false;

  /** @const */
  var METHOD_GET = 'get';

  /** @const */
  var URL_GOOGLE_FONTS_API = 'https://www.googleapis.com/webfonts/v1/webfonts';

  /** @const */
  var URL_GOOGLE_FONTS_CSS = 'http://fonts.googleapis.com/css?';

  /** @const */
  var SUBSET_CYRILLIC = 'cyrillic';

  /** @const */
  var SUBSET_CYRILLIC_EXT = 'cyrillic-ext';

  /** @const */
  var SUBSET_GREEK = 'greek';

  /** @const */
  var SUBSET_GREEK_EXT = 'greek-ext';

  /** @const */
  var SUBSET_LATIN = 'latin';

  /** @const */
  var SUBSET_LATIN_EXT = 'latin-ext';

  /** @const */
  var SUBSET_VIETNAMESE = 'vietnamese';

  /** @const */
  var SUBSET_PRIORITY = [
    SUBSET_LATIN,
    SUBSET_LATIN_EXT,
    SUBSET_GREEK,
    SUBSET_GREEK_EXT,
    SUBSET_CYRILLIC,
    SUBSET_CYRILLIC_EXT,
    SUBSET_VIETNAMESE
  ];

  /** @const */
  var VARIANTS_REGULAR = ['regular', '400', '300', '500'];

  /** @const */
  var VARIANTS_LIGHT = ['light', '100', '200'];

  /** @const */
  var VARIANTS_BOLD = ['bold', '600', '700', '800', '900'];

  /** @const */
  var VARIANTS_ITALIC = ['italic', '400italic', '300italic', '500italic'];

  /** @const */
  var VARIANTS_LIGHT_ITALIC = ['lightitalic', '100italic', '200italic'];

  /** @const */
  var VARIANTS_BOLD_ITALIC = ['bolditalic', '600italic', '700italic', '800italic', '900italic'];

  /** @const */
  var VARIANT_PRIORITY = VARIANTS_REGULAR.concat(
    VARIANTS_LIGHT,
    VARIANTS_BOLD,
    VARIANTS_ITALIC,
    VARIANTS_LIGHT_ITALIC,
    VARIANTS_BOLD_ITALIC
  );

  var _fontsServiceDeps = ['$http', '$q', 'jdFontselectConfig', '$filter'];

  function FontsService() {
    var self = this;

    for (var i = 0, l = _fontsServiceDeps.length; i <l; i++) {
      self[_fontsServiceDeps[i]] = arguments[i];
    }

    self._init();

    return self;
  }

  FontsService.$inject = _fontsServiceDeps;

  FontsService.prototype = {
    _init: function() {
      var self = this;

      self._fonts = self._fonts || {};
      self._map = {};
      self._subsets = [];
      self._subsetNames = {};
      self._addDefaultFonts();
    },

    getAllFonts: function() {
      return this._fonts;
    },

    add: function(fontObj, provider) {
      var self = this;

      if (!angular.isString(provider)) {
        provider = angular.isString(fontObj.provider) ? fontObj.provider : PROVIDER_WEBSAFE;
      }

      fontObj.provider = provider;

      if (!self.isValidFontObject(fontObj)) {
        throw 'Invalid font object.';
      }

      if (!angular.isArray(self._fonts[provider])) {
        self._fonts[provider] = [];
      }

      if (!angular.isObject(self._map[provider])) {
        self._map[provider] = {};
      }

      if (angular.isArray(fontObj.subsets)) {
        self._addSubsets(fontObj.subsets);
      }

      var index = self._fonts[provider].push(fontObj)-1;

      self._map[provider][fontObj.key] = index;
    },

    getFontByKey: function(key, provider) {
      var self = this;

      if (!angular.isString(provider)) {
        throw 'Provider is not set.';
      }

      try {
        return self._fonts[provider][self._map[provider][key]];
      } catch (e) {
        throw 'Font "' + key + '" not found in "' + provider + '".';
      }
    },

    removeFont: function(font, provider) {
      var self = this;

      if (angular.isString(font)) {
        font = self.getFontByKey(font, provider);
      }

      try {
        var index = self._fonts[provider].indexOf(font);
        var retVal = 0;

        if (index >= 0) {
          delete self._map[provider][font.key];
          retVal = self._fonts[provider].splice(index, 1).length;
          self._remap(provider, index);
        }
        return retVal;
      } catch (e) {
        return 0;
      }
    },

    isValidFontObject: function(fontObj) {
      if (!angular.isObject(fontObj)) {
        return false;
      }

      var valid = true;

      angular.forEach(REQUIRED_FONT_OBJECT_KEYS, function(key) {
        if (angular.isUndefined(fontObj[key])) {
          valid = false;
        }
      });

      return valid;
    },

    getCategories: function() {
      return [
        {
          name: 'Serif',
          key: 'serif',
          fallback: 'serif'
        },
        {
          name: 'Sans Serif',
          key: 'sansserif',
          fallback: 'sans-serif'
        },
        {
          name: 'Handwriting',
          key: 'handwriting',
          fallback: 'cursive'

        },
        {
          name: 'Display',
          key: 'display',
          fallback: 'cursive'
        },
        {
          name: 'Other',
          key: 'other',
          fallback: 'sans-serif'
        }
      ];
    },

    getSubsets: function() {
      return this._subsets;
    },

    getSubsetNames: function() {
      return this._subsetNames;
    },

    load: function(font, provider) {
      if (font.loaded) {
        return;
      }

      font.loaded = true;

      if (provider === PROVIDER_WEBSAFE) {
        return;
      }

      this['_load' + provider](font);
    },

    getUrls: function() {
      var self = this;
      var googleUrl = self.getGoogleUrl();
      var urls = {};

      if (googleUrl) {
        urls.google = googleUrl;
      }

      return urls;
    },

    getUsedFonts: function() {
      var self = this;
      var usedFonts = [];

      angular.forEach(self._fonts, function(fonts) {
        usedFonts = usedFonts.concat(self.$filter('filter')(fonts, {used: true}, function(used) {
          return !!used;
        }));
      });

      return usedFonts;
    },

    getGoogleUrl: function() {
      var self = this;
      var googleFonts = self.$filter('filter')(self.getUsedFonts(), {provider: PROVIDER_GOOGLE});

      if (googleFonts.length) {
        var googleNames = [];

        for (var i = 0, l = googleFonts.length; i < l; i++) {
          googleNames.push(googleFonts[i].name);
        }

        return URL_GOOGLE_FONTS_CSS + 'family=' + window.escape(googleNames.join('|'));
      } else {
        return false;
      }
    },

    _remap: function(provider, from) {
      var self = this;
      var fonts = self._fonts[provider];

      if (!angular.isNumber(from)) {
        from = 0;
      }

      for (var i = from, l = fonts.length; i < l; i++) {
        self._map[provider][fonts[i].key] = i;
      }
    },

    _getBestOf: function(things, prios) {
      for (var i = 0, l = prios.length; i < l; i++) {
        var thing = prios[i];
        if (things.indexOf(thing) >= 0) {
          return thing;
        }
      }
      return things[0];
    },

    _getBestVariantOf: function(variants) {
      return this._getBestOf(variants, VARIANT_PRIORITY);
    },

    _getBestSubsetOf: function(subsets) {
      return this._getBestOf(subsets, SUBSET_PRIORITY);
    },

    _initGoogleFonts: function() {
      var self = this;

      if (!self.jdFontselectConfig.googleApiKey) {
        return;
      }

      self.$http({
        method: METHOD_GET,
        url: URL_GOOGLE_FONTS_API,
        params: {
          sort: 'popularity',
          key: self.jdFontselectConfig.googleApiKey
        }
      }).success(function(response) {
        var amount = response.items.length;

        angular.forEach(response.items, function(font, i) {
          var category = self._getGoogleFontCat(font.family);
          if (SUPPORT_KHMER || font.subsets.length === 1 && font.subsets[0] === 'khmer') {
            return;
          }

          self.add({
            subsets: font.subsets,
            variants: font.variants,
            name: font.family,
            popularity: amount - i,
            key: _createKey(font.family),
            lastModified: font.lastModified,
            stack: '"' + font.family + '", ' + category.fallback,
            category: category.key
          }, PROVIDER_GOOGLE);
        });
      });
    },

    _addSubsets: function(subsets) {
      for (var i = 0, l = subsets.length; i < l; i++) {
        this._addSubset(subsets[i]);
      }
    },

    _addSubset: function(subset) {
      var self = this;

      if (self._subsets.indexOf(subset) < 0) {
        var fragments = subset.split('-');

        for (var i = 0, l = fragments.length; i < l; i++) {
          fragments[i] = fragments[i].charAt(0).toUpperCase() + fragments[i].slice(1);
        }

        self._subsetNames[subset] = fragments.join(' ');
        self._subsets.push(subset);
      }
    },

    _getGoogleFontCat: function(font) {
      var self = this;

      var categories = self.getCategories();
      for (var i = 0, l = categories.length; i < l; i++) {
        var category = categories[i];

        if (typeof GOOGLE_FONT_CATEGORIES[category.name] === 'undefined') {
          continue;
        }

        if (GOOGLE_FONT_CATEGORIES[category.name].indexOf(font) >= 0) {
          return category;
        }
      }

      // console.error('Category not Found:', font);
      return categories[5];
    },

    _addDefaultFonts: function() {
      var self = this;

      angular.forEach(DEFAULT_WEBSAFE_FONTS, function(font) {
        self.add(font);
      });
    }
  };

  FontsService.prototype['_load' + PROVIDER_GOOGLE] = function(font) {
    var self = this;

    try {
      WebFont.load({
        google: {
          families: [font.name + ':' + self._getBestVariantOf(font.variants)],
          text: font.name,
          subsets: font.subsets,
          subset: self._getBestSubsetOf(font.subsets)
        }
      });
    } catch (e) {
      self.removeFont(font, PROVIDER_GOOGLE);
    }
  };

  fontselectModule.factory(NAME_FONTSSERVICE, ['$injector', function($injector) {
    return $injector.instantiate(FontsService);
  }]);

  // src/js/directive.fontselect.js
  var id = 1;

  fontselectModule.directive('jdFontselect', [NAME_FONTSSERVICE, '$rootScope', function(fontsService, $rootScope) {
    return {
      scope: {
        current: '=?state',
        selected: '=?'
      },
      restrict: 'E',
      templateUrl: 'fontselect.html',
      replace: true,
      controller: ['$scope', function($scope) {
        $scope.fonts = fontsService.getAllFonts();
        $scope.id = id++;
        $scope.providers = PROVIDERS;
        $scope.active = false;
        $scope.categories = fontsService.getCategories();
        $scope.subsets = fontsService.getSubsetNames();
        $scope.searchAttrs = [
          {
            name: 'Popularity',
            key: 'popularity',
            dir: true
          },
          {
            name: 'Alphabet',
            key: 'name',
            dir: false
          },
          {
            name: 'Latest',
            key: 'lastModified',
            dir: true
          }
        ];

        $scope.selected = $scope.selected || {};

        $scope.current = angular.extend({
          sort: {
            attr: $scope.searchAttrs[0],
            direction: true
          },
          provider: PROVIDER_WEBSAFE,
          category: undefined,
          font: undefined,
          search: undefined,
          subsets: {
            latin: true
          }
        }, $scope.current || {});

        $scope.reverseSort = function() {
          var sort = $scope.current.sort;

          sort.direction = !sort.direction;
        };

        $scope.toggle = function() {
          $scope.active = !$scope.active;
        };

        $scope.setCategoryFilter = function(category) {
          var current = $scope.current;

          if (current.category === category) {
            current.category = undefined;
          } else {
            current.category = category;
          }
        };
      }],
      link: function(scope) {

        scope.$watch('current.font', function(newFont, oldFont) {
          if (oldFont !== newFont && angular.isObject(scope.current.font)) {
            newFont = scope.current.font;

            if (angular.isObject(oldFont) && oldFont.used) {
              oldFont.used--;
            }
            if (!angular.isObject(newFont) || !newFont.used) {
              newFont.used = 1;
            } else {
              newFont.used++;
            }

            scope.selected.name = newFont.name;
            scope.selected.stack = newFont.stack;
            $rootScope.$broadcast('jdfs.change', scope.selected);
          }
        });
      }
    };
  }]);

  // src/js/directive.fontlist.js
  var NAME_JDFONTLIST = 'jdFontlist';
  var NAME_JDFONTLIST_CONTROLLER = NAME_JDFONTLIST + NAME_CONTROLLER;

  fontselectModule.directive(NAME_JDFONTLIST, function() {
    return {
      scope: {
        id: '=fsid',
        fonts: '=',
        current: '=',
        providerName: '@provider'
      },
      restrict: 'E',
      templateUrl: 'fontlist.html',
      replace: true,
      controller: NAME_JDFONTLIST_CONTROLLER
    };
  });

  fontselectModule.controller(NAME_JDFONTLIST_CONTROLLER, [
    '$scope',
    '$filter',
    'jdFontselect.fonts',
    function($scope, $filter, fontsService) {
      var _filteredFonts;
      var _sortedFonts;
      var _categorizedFonts;
      var _fontsInSubsets;
      var _lastPageCount = 0;
      var _activated = [PROVIDER_WEBSAFE];
      var _initiate = {};
      var _sortCache = {};

      $scope.page = {
        size: 30,
        count: 0,
        current: 0
      };

      $scope.providerKey = _createKey($scope.providerName);

      /**
       * Set the current page
       *
       * @param {Number} currentPage
       * @return {void}
       */
      $scope.setCurrentPage = function(currentPage) {
        $scope.page.current = currentPage;
      };

      /**
       * Get an array with the length similar to the
       * amount of pages we have. (So we can use it in a repeater)
       *
       * Also update the current page and the current amount of pages.
       *
       * @return {Array}
       */
      $scope.getPages = function() {
        _updatePageCount();
        var pages = new Array($scope.page.count);

        _updateCurrentPage();

        /* Display the page buttons only if we have at least two pages. */
        if (pages.length <= 1) {
          return [];
        }
        return pages;
      };

      /**
       * Check if this list is active
       *
       * @return {Boolean}
       */
      $scope.isActive = function() {
        return $scope.current.provider === $scope.providerName;
      };

      /**
       * Apply the current filters to our internal font object.
       *
       * Ensure we only apply filters when the filter parameters
       * or the source have changed.
       *
       * @return {Array}
       */
      $scope.getFilteredFonts = function() {
        if (!angular.isArray($scope.fonts)) {
          _filteredFonts = [];
        } else {
          var direction = $scope.current.sort.attr.dir;

          /* Apply all filters if the source is new. */
          if ($scope.fonts.length !== _sortCache.sourceCache) {
            _sortCache.sourceCache = $scope.fonts.length;
            /* ESKALATE! */
            _sortCache.subsets = null;
          }

          if (_sortCache.subsets !== JSON.stringify($scope.current.subsets)) {
            _sortCache.subsets = JSON.stringify($scope.current.subsets);
            _sortCache.sortdir = null;

            _fontsInSubsets = $filter('hasAllSubsets')(
              $scope.fonts,
              $scope.current.subsets
            );
          }

          if (_sortCache.sortattr !== $scope.current.sort.attr.key ||
            _sortCache.sortdir !== $scope.current.sort.direction)
          {
            _sortCache.sortattr = $scope.current.sort.attr.key;
            _sortCache.sortdir = $scope.current.sort.direction;
            _sortCache.category = null;

            _sortedFonts = $filter('orderBy')(
              _fontsInSubsets,
              $scope.current.sort.attr.key,
              $scope.current.sort.direction ? direction : !direction
            );
          }

          if (_sortCache.category !== $scope.current.category) {
            _sortCache.category = $scope.current.category;
            _sortCache.search = null;

            _categorizedFonts = $filter('filter')(_sortedFonts, {category: $scope.current.category}, true);
          }

          /* check if the source is the same */
          if (_sortCache.search !== $scope.current.search) {
            _sortCache.search = $scope.current.search;

            _filteredFonts = $filter('fuzzySearch')(_categorizedFonts, {name: $scope.current.search});
          }

        }

        return _filteredFonts;
      };

      /**
       * Activate or deactivate the this List.
       *
       * @return {void}
       */
      $scope.toggle = function() {
        if ($scope.isActive()) {
          $scope.current.provider = undefined;
        } else {
          if (_activated.indexOf($scope.providerName) < 0) {
            _initiate[$scope.providerName]();
            _activated.push($scope.providerName);
          }
          $scope.current.provider = $scope.providerName;
        }
      };

      /**
       * Calculate the amount of pages we have.
       *
       * @return {void}
       */
      function _updatePageCount() {
        _lastPageCount = $scope.page.count;

        if (!angular.isArray($scope.fonts)) {
          return 0;
        }

        if (_filteredFonts.length) {
          $scope.page.count = Math.ceil(_filteredFonts.length / $scope.page.size);
        }
      }

      /**
       * Whenever the amount of pages is changing:
       * Make sure we're not staying on a page that does not exist.
       * And if we have a font selected, try to stay on the page of
       * that font.
       *
       * @return {void}
       */
      function _updateCurrentPage() {
        /* do nothing if the amount of pages hasn't change */
        if (_lastPageCount === $scope.page.count) {
          return;
        }

        var currentFont = $scope.current.font;

        /* check if the current font is anywhere on our current pages */
        var index = _filteredFonts.indexOf(currentFont);

        /* If we have a font selected and it's inside the filter we use */
        if (currentFont && index >= 0) {
          /* go to this page */
          $scope.page.current = Math.ceil((index + 1) / $scope.page.size) - 1;
        } else {
          /* Just go to the last page if the current does not exist */
          if ($scope.page.current > $scope.page.count) {
            $scope.page.current = $scope.page.count-1;
          }
        }
      }

      /**
       * Initiation for the google list.
       *
       * @return {void}
       */
      _initiate[PROVIDER_GOOGLE] = function() {
        fontsService._initGoogleFonts();
      };
    }
  ]);

  // src/js/directive.font.js
  fontselectModule.directive('jdFont', ['jdFontselect.fonts', function(fontsService) {
    return {
      templateUrl: 'font.html',
      restrict: 'E',
      replace: true,
      controller: ['$scope', function($scope) {
        fontsService.load($scope.font, $scope.providerName);
      }]
    };
  }]);

  // src/js/directive.current-href.js
  fontselectModule.directive('jdFontselectCurrentHref', [NAME_FONTSSERVICE, function(fontsService) {
    return {
      templateUrl: 'current-href.html',
      restrict: 'A',
      replace: true,
      controller: ['$scope', function($scope) {
        $scope.urls = [];
        $scope.$on('jdfs.change', function() {
          $scope.urls = fontsService.getUrls();
        });
      }]
    };
  }]);

  // src/partials/all.js
  angular.module('jdFontselect').run(['$templateCache', function($templateCache) {
    'use strict';

    $templateCache.put('current-href.html',
      "<link ng-href={{url}} ng-repeat=\"url in urls\">"
    );

    $templateCache.put('font.html',
      "<li><input type=radio ng-model=current.font ng-value=font name=jdfs-{{id}}-font id=jdfs-{{id}}-font-{{font.key}}><label ng-class=\"{'jdfs-active': current.font == font}\" for=jdfs-{{id}}-font-{{font.key}} style=\"font-family: {{font.stack}}\">{{font.name}}</label></li>"
    );

    $templateCache.put('fontlist.html',
      "<div class=\"jdfs-provider jdfs-provider-{{providerKey}}\" ng-class=\"{'jdfs-active': isActive()}\"><p class=jdfs-provider-title ng-class=\"{'jdfs-active': isActive()}\" ng-click=toggle()>{{providerName}} <span ng-if=\"getFilteredFonts().length == fonts.length\">({{fonts.length}})</span> <span ng-if=\"fonts.length && getFilteredFonts().length != fonts.length\">({{getFilteredFonts().length}}/{{fonts.length}})</span> <span ng-if=!fonts.length>(…)</span></p><div ng-if=isActive()><ul class=jdfs-fontlist><jd-font ng-repeat=\"font in getFilteredFonts() | startFrom: page.current * page.size | limitTo: page.size\"></ul><button ng-repeat=\"i in getPages() track by $index\" ng-class=\"{'jdfs-active': page.current == $index}\" ng-click=setCurrentPage($index)>{{$index + 1}}</button></div></div>"
    );

    $templateCache.put('fontselect.html',
      "<div class=jdfs-main id=jd-fontselect-{{id}}><button ng-click=toggle() class=jdfs-toggle>Current Font</button><input class=jdfs-search placeholder=\"Search by Fontname\" name=jdfs-{{id}}-search ng-model=current.search><div class=jdfs-window ng-show=active><div class=jdfs-fontlistcon><jd-fontlist fsid=id current=current fonts=fonts[provider] provider={{provider}} ng-repeat=\"provider in providers\"></div><div class=jdfs-filter><button class=jdfs-filterbtn ng-repeat=\"category in categories\" ng-class=\"{'jdfs-active': category.key == current.category}\" ng-click=setCategoryFilter(category.key) ng-model=current.category>{{category.name}}</button><div class=jdfs-charsets><div ng-repeat=\"(key, name) in subsets\"><input ng-model=current.subsets[key] type=checkbox id=jdfs-{{id}}-subset-{{key}}><label for=jdfs-{{id}}-subset-{{key}}>{{name}}</label></div></div></div></div></div>"
    );

  }]);
})(angular);


text:
'use strict';

exports.__esModule = true;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _classnames = require('classnames');

var _classnames2 = _interopRequireDefault(_classnames);

var _dates = require('./utils/dates');

var _dates2 = _interopRequireDefault(_dates);

var _accessors = require('./utils/accessors');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }

var EventCell = _react2.default.createClass({
  displayName: 'EventCell',
  render: function render() {
    var _props = this.props;
    var className = _props.className;
    var event = _props.event;
    var selected = _props.selected;
    var eventPropGetter = _props.eventPropGetter;
    var startAccessor = _props.startAccessor;
    var endAccessor = _props.endAccessor;
    var titleAccessor = _props.titleAccessor;
    var slotStart = _props.slotStart;
    var slotEnd = _props.slotEnd;
    var onSelect = _props.onSelect;
    var component = _props.component;

    var props = _objectWithoutProperties(_props, ['className', 'event', 'selected', 'eventPropGetter', 'startAccessor', 'endAccessor', 'titleAccessor', 'slotStart', 'slotEnd', 'onSelect', 'component']);

    var Component = component;

    var title = (0, _accessors.accessor)(event, titleAccessor),
        end = (0, _accessors.accessor)(event, endAccessor),
        start = (0, _accessors.accessor)(event, startAccessor),
        isAllDay = (0, _accessors.accessor)(event, props.allDayAccessor),
        continuesPrior = _dates2.default.lt(start, slotStart, 'day'),
        continuesAfter = _dates2.default.gt(end, slotEnd, 'day');

    if (eventPropGetter) {
      var _eventPropGetter = eventPropGetter(event, start, end, selected);

      var style = _eventPropGetter.style;
      var xClassName = _eventPropGetter.className;
    }

    return _react2.default.createElement(
      'div',
      _extends({}, props, {
        style: _extends({}, props.style, style),
        className: (0, _classnames2.default)('rbc-event', className, xClassName, {
          'rbc-selected': selected,
          'rbc-event-allday': isAllDay || _dates2.default.diff(start, _dates2.default.ceil(end, 'day'), 'day') > 1,
          'rbc-event-continues-prior': continuesPrior,
          'rbc-event-continues-after': continuesAfter
        }),
        onClick: function onClick() {
          return onSelect(event);
        }
      }),
      _react2.default.createElement(
        'div',
        { className: 'rbc-event-content', title: title },
        Component ? _react2.default.createElement(Component, { event: event, title: title }) : title
      )
    );
  }
});

exports.default = EventCell;
module.exports = exports['default'];


text:
--------------------------------
--
-- @function [parent=#ParticleSmoke] createWithTotalParticles
-- @param self
-- @param #int numberOfParticles
-- @return ParticleSmoke#ParticleSmoke ret (return value: cc.ParticleSmoke)

return nil


text:
@org.eclipse.jdt.annotation.NonNullByDefault
package org.locationtech.geogig.model;


text:
namespace arrow {

// ----------------------------------------------------------------------
// Primitive array base

PrimitiveArray::PrimitiveArray(const std::shared_ptr<DataType>& type, int64_t length,
                               const std::shared_ptr<Buffer>& data,
                               const std::shared_ptr<Buffer>& null_bitmap,
                               int64_t null_count, int64_t offset) {
  SetData(ArrayData::Make(type, length, {null_bitmap, data}, null_count, offset));
}

// ----------------------------------------------------------------------
// BooleanArray

BooleanArray::BooleanArray(const std::shared_ptr<ArrayData>& data)
    : PrimitiveArray(data) {
  ARROW_CHECK_EQ(data->type->id(), Type::BOOL);
}

BooleanArray::BooleanArray(int64_t length, const std::shared_ptr<Buffer>& data,
                           const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count,
                           int64_t offset)
    : PrimitiveArray(boolean(), length, data, null_bitmap, null_count, offset) {}

int64_t BooleanArray::false_count() const {
  return this->length() - this->null_count() - this->true_count();
}

int64_t BooleanArray::true_count() const {
  if (data_->null_count.load() != 0) {
    DCHECK(data_->buffers[0]);
    return internal::CountAndSetBits(data_->buffers[0]->data(), data_->offset,
                                     data_->buffers[1]->data(), data_->offset,
                                     data_->length);
  } else {
    return internal::CountSetBits(data_->buffers[1]->data(), data_->offset,
                                  data_->length);
  }
}

// ----------------------------------------------------------------------
// Day time interval

DayTimeIntervalArray::DayTimeIntervalArray(const std::shared_ptr<ArrayData>& data) {
  SetData(data);
}

DayTimeIntervalArray::DayTimeIntervalArray(const std::shared_ptr<DataType>& type,
                                           int64_t length,
                                           const std::shared_ptr<Buffer>& data,
                                           const std::shared_ptr<Buffer>& null_bitmap,
                                           int64_t null_count, int64_t offset)
    : PrimitiveArray(type, length, data, null_bitmap, null_count, offset) {}

DayTimeIntervalArray::DayTimeIntervalArray(int64_t length,
                                           const std::shared_ptr<Buffer>& data,
                                           const std::shared_ptr<Buffer>& null_bitmap,
                                           int64_t null_count, int64_t offset)
    : PrimitiveArray(day_time_interval(), length, data, null_bitmap, null_count, offset) {
}

DayTimeIntervalType::DayMilliseconds DayTimeIntervalArray::GetValue(int64_t i) const {
  DCHECK(i < length());
  return *reinterpret_cast<const DayTimeIntervalType::DayMilliseconds*>(
      raw_values_ + (i + data_->offset) * byte_width());
}

// ----------------------------------------------------------------------
// Month, day and Nanos interval

MonthDayNanoIntervalArray::MonthDayNanoIntervalArray(
    const std::shared_ptr<ArrayData>& data) {
  SetData(data);
}

MonthDayNanoIntervalArray::MonthDayNanoIntervalArray(
    const std::shared_ptr<DataType>& type, int64_t length,
    const std::shared_ptr<Buffer>& data, const std::shared_ptr<Buffer>& null_bitmap,
    int64_t null_count, int64_t offset)
    : PrimitiveArray(type, length, data, null_bitmap, null_count, offset) {}

MonthDayNanoIntervalArray::MonthDayNanoIntervalArray(
    int64_t length, const std::shared_ptr<Buffer>& data,
    const std::shared_ptr<Buffer>& null_bitmap, int64_t null_count, int64_t offset)
    : PrimitiveArray(month_day_nano_interval(), length, data, null_bitmap, null_count,
                     offset) {}

MonthDayNanoIntervalType::MonthDayNanos MonthDayNanoIntervalArray::GetValue(
    int64_t i) const {
  DCHECK(i < length());
  return *reinterpret_cast<const MonthDayNanoIntervalType::MonthDayNanos*>(
      raw_values_ + (i + data_->offset) * byte_width());
}

}  // namespace arrow


text:
namespace Merchello.Web.Models.MapperResolvers
{
    using System.Collections.Generic;
    using System.Linq;

    using AutoMapper;
    using Core.Models;

    /// <summary>
    /// Custom AutoMapper Resolver - Maps <see cref="ExtendedDataCollection"/> to an Enumerable
    /// </summary>
    /// <remarks>
    ///
    /// Fixes issue M-211 http://issues.merchello.com/youtrack/issue/M-211
    ///
    /// </remarks>
    internal class ExtendedDataResolver : ValueResolver<IHasExtendedData, IEnumerable<KeyValuePair<string, string>>>
    {
        /// <summary>
        /// The resolve core.
        /// </summary>
        /// <param name="source">
        /// The source.
        /// </param>
        /// <returns>
        /// A collection of key value pairs that represent an <see cref="ExtendedDataCollection"/>
        /// </returns>
        protected override IEnumerable<KeyValuePair<string, string>> ResolveCore(IHasExtendedData source)
        {
            return source.ExtendedData.AsEnumerable();
        }
    }
}


text:
using System;
using System.Linq;
using CommandLine;

namespace Elders.Skynet.Subprocess
{
    public class Program
    {
        static log4net.ILog log = log4net.LogManager.GetLogger(typeof(Program));

        static void Main(string[] args)
        {
            log4net.Config.XmlConfigurator.Configure();
            var commands = typeof(Program).Assembly.GetTypes().Where(x => typeof(ICliCommand).IsAssignableFrom(x));
            try
            {
                var result = Parser.Default.ParseArguments(args, commands.ToArray());
                result.WithNotParsed(errors =>
                {
                    if (errors.Any())
                    {
                        log.Error("Exit Code: 1");
                        Environment.Exit(1);
                    }
                });
                result.WithParsed(x => (x as ICliCommand).Execute());

            }
            catch (Exception ex)
            {
                log.Error("Exit Code: 1", ex);
                Environment.Exit(1);
            }

            log.Info("Exit Code: 1");
        }
    }

    public interface ICliCommand
    {
        void Execute();
    }
}


text:
from kafka.tools.assigner.actions.balancemodules.size import ActionBalanceSize
from kafka.tools.assigner.actions import ActionBalanceModule

class ActionBalanceRate(ActionBalanceModule):
    name = "rate"
    helpstr = "Move the busiest partitions in the cluster to even the total bytes rate per-broker for each replica position"

    def __init__(self, args, cluster):
        super(ActionBalanceRate, self).__init__(args, cluster)

        # This module merely calls the balance "size" module with the scaled_size attr, so we're going to instantiate a copy of that
        self._size = ActionBalanceSize(args, cluster, size_attr='scaled_size')

    def process_cluster(self):
        # Call the size module
        self._size.process_cluster()


text:
title: Google Spreadsheets first lesson
layout: post
author: toby.wonnacott
permalink: /untitled-document/
source-id: 14Kzm6CXFoNU8cb_Yu9chMDmQY7Wk6jjpQVnu8z91lP4
published: true
---

    Title

    Date
    01/01/01

    Starting point:

    Target for this lesson?

    Did I reach my target?
(add details to "Lesson Review")

    Lesson Review

    How did I learn? What strategies were effective?

    I learned by exploring what I could do through the simple basic codes we were instructed to do from Mr Keen. Since we did some spreadsheets in my old school, I had a vague idea of how to use spreadsheets but I just needed a refresher.

    .There was not too much that limited my learning as the task was quite simple this first lesson, however it took a bit of time to get used to writing in the first few easy codes as it was the first lesson of the year.

    What will I change for next time? How will I improve my learning?

    I will try to improve my learning by remembering how to quickly write in codes and use the shortcuts for spreadsheets

 Spreadsheet


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>cam-occ: src/contrib/salome/ShHealOper_SplitCurve3d.hxx File Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="doxygen.css" rel="stylesheet" type="text/css"/>

Main Page

Classes

Files

File List

File Members

Classes

src/contrib/salome/ShHealOper_SplitCurve3d.hxx File Reference

#include <limits.h>

#include <ShapeUpgrade_SplitCurve3d.hxx>

#include <TColStd_HSequenceOfReal.hxx>

#include <Standard_DefineHandle.hxx>

Include dependency graph for ShHealOper_SplitCurve3d.hxx:

<map name="src_2contrib_2salome_2_sh_heal_oper___split_curve3d_8hxx" id="src_2contrib_2salome_2_sh_heal_oper___split_curve3d_8hxx">
</map>

This graph shows which files directly or indirectly include this file:

<map name="src_2contrib_2salome_2_sh_heal_oper___split_curve3d_8hxxdep" id="src_2contrib_2salome_2_sh_heal_oper___split_curve3d_8hxxdep">
<area shape="rect" id="node3" href="_sh_heal_oper___edge_divide_8cpp.html" title="src/contrib/salome/ShHealOper_EdgeDivide.cpp" alt="" coords="5,86,307,117"/><area shape="rect" id="node5" href="_sh_heal_oper___split_curve3d_8cpp.html" title="src/contrib/salome/ShHealOper_SplitCurve3d.cpp" alt="" coords="331,86,640,117"/></map>

Go to the source code of this file.

Classes

class  	ShHealOper_SplitCurve3d

 	Auxiliary class for class ShHealOper_EdgeDivide.  More...

<address class="footer">Generated by

 1.7.1 </address>


text:
float my_random_float();

float my_random_float2();

double my_random_double();

float dummy();

float dummy2();

float random_float();

float random_double();


text:
/* $Id: vfprintf.c 481 2010-12-08 05:53:09Z solar $ */

/* vfprintf( FILE *, const char *, va_list )

   This file is part of the Public Domain C Library (PDCLib).
   Permission is granted to use, modify, and / or redistribute at will.
*/

#include <stdio.h>
#include <stdarg.h>
#include <stdint.h>

#ifndef REGTEST

int vfprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, va_list arg )
{
    /* TODO: This function should interpret format as multibyte characters.  */
    struct _PDCLIB_status_t status;
    status.base = 0;
    status.flags = 0;
    status.n = SIZE_MAX;
    status.i = 0;
    status.current = 0;
    status.s = NULL;
    status.width = 0;
    status.prec = 0;
    status.stream = stream;
    va_copy( status.arg, arg );

    while ( *format != '\0' )
    {
        const char * rc;
        if ( ( *format != '%' ) || ( ( rc = _PDCLIB_print( format, &status ) ) == format ) )
        {
            /* No conversion specifier, print verbatim */
            putc( *(format++), stream );
            status.i++;
        }
        else
        {
            /* Continue parsing after conversion specifier */
            format = rc;
        }
    }
    va_end( status.arg );
    return status.i;
}

#endif

#ifdef TEST
#define _PDCLIB_FILEID "stdio/vfprintf.c"
#define _PDCLIB_FILEIO

#include <_PDCLIB_test.h>

static int testprintf( FILE * stream, const char * format, ... )
{
    int i;
    va_list arg;
    va_start( arg, format );
    i = vfprintf( stream, format, arg );
    va_end( arg );
    return i;
}

int main( void )
{
    FILE * target;
    TESTCASE( ( target = tmpfile() ) != NULL );
#include "printf_testcases.h"
    TESTCASE( fclose( target ) == 0 );
    return TEST_RESULTS;
}

#endif


text:
<?php

namespace ZendSearch\Lucene\Analysis\Analyzer\Common\TextNum;

use ZendSearch\Lucene\Analysis\Analyzer\Common;
use ZendSearch\Lucene\Analysis\TokenFilter;

/**
 * @category   Zend
 * @package    Zend_Search_Lucene
 * @subpackage Analysis
 */
class CaseInsensitive extends Common\TextNum
{
    public function __construct()
    {
        $this->addFilter(new TokenFilter\LowerCase());
    }
}


text:
<!DOCTYPE html>
<meta charset="utf-8">
<title>Redirecting…</title>
<link rel="canonical" href="/blogs/office/excel/videos-tutoriais-de-120-segundos/">
<meta http-equiv="refresh" content="0; url=/blogs/office/excel/videos-tutoriais-de-120-segundos/">

Redirecting…

Click here if you are not redirected.


text:
package box2d_PulleyJoint;

import com.thomasdiewald.liquidfun.java.DwWorld;

import org.jbox2d.collision.shapes.CircleShape;
import org.jbox2d.collision.shapes.EdgeShape;
import org.jbox2d.collision.shapes.PolygonShape;
import org.jbox2d.common.Vec2;
import org.jbox2d.dynamics.Body;
import org.jbox2d.dynamics.BodyDef;
import org.jbox2d.dynamics.BodyType;
import org.jbox2d.dynamics.joints.Joint;
import org.jbox2d.dynamics.joints.PulleyJoint;
import org.jbox2d.dynamics.joints.PulleyJointDef;
import processing.core.*;
import processing.opengl.PGraphics2D;

public class box2d_PulleyJoint extends PApplet {

  //
  // This examples shows how to use PulleyJoints.
  //
  // Controls:
  //
  // LMB         ... drag bodies
  // LMB + SHIFT ... shoot bullet
  // MMB         ... add particles
  // RMB         ... remove particles
  // 'r'         ... reset
  // 't'         ... update/pause physics
  // 'f'         ... toggle debug draw
  //

  int viewport_w = 1280;
  int viewport_h = 720;
  int viewport_x = 230;
  int viewport_y = 0;

  boolean UPDATE_PHYSICS = true;
  boolean USE_DEBUG_DRAW = false;

  DwWorld world;

  public void settings(){
    size(viewport_w, viewport_h, P2D);
    smooth(8);
  }

  public void setup(){
    surface.setLocation(viewport_x, viewport_y);
    reset();
    frameRate(120);
  }

  public void release(){
    if(world != null) world.release(); world = null;
  }

  public void reset(){
    // release old resources
    release();

    world = new DwWorld(this, 20);

    // create scene: rigid bodies, particles, etc ...
    initScene();
  }

  public void draw(){

    if(UPDATE_PHYSICS){
      world.update();
    }

    PGraphics2D canvas = (PGraphics2D) this.g;
    canvas.background(32);
    canvas.pushMatrix();
    world.applyTransform(canvas);
    world.drawBulletSpawnTrack(canvas);
    if(USE_DEBUG_DRAW){
      world.displayDebugDraw(canvas);
      // DwDebugDraw.display(canvas, world);
    } else {
      world.display(canvas);
    }
    canvas.popMatrix();

    // info
    int num_bodies    = world.getBodyCount();
    int num_particles = world.getParticleCount();
    String txt_fps = String.format(getClass().getName()+ " [bodies: %d]  [particles: %d]  [fps %6.2f]", num_bodies, num_particles, frameRate);
    surface.setTitle(txt_fps);
  }

  //////////////////////////////////////////////////////////////////////////////
  // User Interaction
  //////////////////////////////////////////////////////////////////////////////
  public void keyReleased(){
    if(key == 't') UPDATE_PHYSICS = !UPDATE_PHYSICS;
    if(key == 'r') reset();
    if(key == 'f') USE_DEBUG_DRAW = !USE_DEBUG_DRAW;
  }

  //////////////////////////////////////////////////////////////////////////////
  // Scene Setup
  //////////////////////////////////////////////////////////////////////////////

  // https://github.com/jbox2d/jbox2d/blob/master/jbox2d-testbed/src/main/java/org/jbox2d/testbed/tests/Pulleys.java
  public void initScene() {

    float y = 16.0f;
    float L = 12.0f;
    float a = 1.0f;
    float b = 2.0f;
    Body ground = null;
    {
      BodyDef bd = new BodyDef();
      ground = world.createBody(bd);

      EdgeShape shape = new EdgeShape();
      shape.set(new Vec2(-40.0f, 0.0f), new Vec2(40.0f, 0.0f));
      ground.createFixture(shape, 0.0f);

      CircleShape circle = new CircleShape();
      circle.m_radius = 2.0f;

      circle.m_p.set(-10.0f, y + b + L);
      ground.createFixture(circle, 0.0f);

      circle.m_p.set(10.0f, y + b + L);
      ground.createFixture(circle, 0.0f);

      world.bodies.add(ground, true, color(220, 128), true, color(255), 1f);
    }

    {

      PolygonShape shape = new PolygonShape();
      shape.setAsBox(a, b);

      BodyDef bd = new BodyDef();
      bd.type = BodyType.DYNAMIC;

      bd.position.set(-10.0f, y);
      Body body1 = world.createBody(bd);
      body1.createFixture(shape, 5.0f);

      bd.position.set(10.0f, y);
      Body body2 = world.createBody(bd);
      body2.createFixture(shape, 5.0f);

      world.bodies.add(body1, true, color(0,128,255), true, color(0), 1f);
      world.bodies.add(body2, true, color(0,128,255), true, color(0), 1f);

      PulleyJointDef pulleyDef = new PulleyJointDef();
      Vec2 anchor1 = new Vec2(-10.0f, y + b);
      Vec2 anchor2 = new Vec2(10.0f, y + b);
      Vec2 groundAnchor1 = new Vec2(-10.0f, y + b + L);
      Vec2 groundAnchor2 = new Vec2(10.0f, y + b + L);
      pulleyDef.initialize(body1, body2, groundAnchor1, groundAnchor2, anchor1, anchor2, 2.0f);

      Joint m_joint1 = (PulleyJoint) world.createJoint(pulleyDef);

      world.bodies.add(m_joint1, false, color(0), true, color(255,128,64), 1f);
    }

  }

  public static void main(String args[]) {
    PApplet.main(new String[] { box2d_PulleyJoint.class.getName() });
  }

}


text:
define([
    './FindByUrlMixin',
    'dojo/request/handlers',
    'dojo/request/xhr',
    'dojo/store/util/QueryResults',
    'dojo/Deferred',
    "dojo/_base/lang",
    "dojo/_base/declare",
    "dojo/store/JsonRest"//
], function (FindByUrlMixin, handlers, xhr, QueryResults, Deferred, lang, declare, JsonRest) {

    return declare([ JsonRest , FindByUrlMixin], {
        query: function (query, options) {
            var params = {};
            lang.mixin(params,query);

            if (options && options.sort) {
                var sort = [];
                options.sort.forEach(function (col) {
                    sort.push(col.attribute + (col.descending ? "-" : ""));
                });
                params.sort = sort.join("  ");

            }
            var totalCount=0;
            if (options) {
                params.skip = options.start;
                params.limit = options.count;
                totalCount=options.start;
            }

            var results = xhr.get(this.target, {query: params, handleAs: "json"});
            var totalPromise = new Deferred();
            results.then(function(res) {
                    totalPromise.resolve(res.length);
            })
           results.total = totalPromise;
            return new QueryResults(results);
        }, add: function (object, options) {
            object[this.idProperty]=object.name;
            options = options || {};

            var noHandler = function (value) {
                return value;
            }
            handlers.register("raw", noHandler);

            var promise = xhr.post(this.target, {
                data: JSON.stringify(object),
                "handleAs": "json",
                headers: lang.mixin({
                    "Content-Type": "application/json",
                    Accept: this.accepts//,
                    // "If-Match": "*",
                    //"If-None-Match": null
                }, this.headers, options.headers)
            })

            var newPromise = new Deferred();
            promise.then(lang.hitch(this, "onAdded", newPromise), newPromise.reject);
            return newPromise;
        }, onAdded: function (promise, response) {
            var id = response;
            promise.resolve(id);
        }
    });

});