text:
---
layout: default
---

# 1996-10-07 - Re: "Drift net fishing," GAK, FBI, and NSA

## Header Data

From: "Timothy C. May"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: fe43b45e3dc5c75936dda4bd1d0a22940566de13a22454e0d12fee2e8dcae830

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-10-07 02:25:22 UTC

Raw Date: Mon, 7 Oct 1996 10:25:22 +0800

## Raw message

```
{% raw  %}From: "Timothy C. May"<EMAIL_ADDRESS>Date: Mon, 7 Oct 1996 10:25:22 +0800
To<EMAIL_ADDRESS>Subject: Re: "Drift net fishing," GAK, FBI, and NSA
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 2:05 PM -0700 10/6/96, Steve Schear wrote:
(quoting me)

>>(They already got access to the credit card databases, decades ago, of
>>course.)
>>
>
>Are SSN and other ID required when opening a 'pre-paid' credit card
>account?  That is, the ones for persons with poor credit who are required
>to maintain a balance sufficient to pay off the charges?  Perhaps we could
>put our heads together and determine a way to become franchised by MC/VISA
>and offer 'affinity' type accounts with no address requirements (all
>statments are sent via remailer/nym email).

A couple of people on this list talked about a similar thing, a "Privacy
Card," with the explicit policy of not reporting transactions in detail to
the Big Three (the government-friendly TRW Credit, Equifax, and Transunion).

The idea being that if a "market for privacy" exists, someone ought to be
able to make a nice piece of change offering a card that protects privacy.

One problem is that many people _want_ credit card transactions reported to
the Big Three, to build up their credit record.

(But many don't care. I've been using a VISA card issued by my stock broker
for 12 years now. It's a "debit card," though it's handled by a merchant
exactly as a credit card, and they probably can't see any difference. What
I gathered when buying my current house, is that none of these transactions
were part of my "credit history," as I was actually using a debit card. All
of those now using, or planning to use, a debit card would be ideal
candidates for a "Privacy Card.")

Such a deal would have to be one of Visa, MasterCard, or Discover, with
American Express a distant fourth. (I don't even know if these
companies/tradenames would even allow such a thing, of course.) The cost of
rolling out a brand new type of card would of course be prohibitively high.

(I have no expectation than this will be done, and I think I said so at the
time. Ever the realist, in some ways,  I knew no one would take on such a
complex project. Just as no one followed through with the "Cypherpunks
Credit Union" idea, discussed at several meetings in 1993.)

--Tim May

"The government announcement is disastrous," said Jim Bidzos,.."We warned IBM
that the National Security Agency would try to twist their technology."
[NYT, 1996-10-02]
We got computers, we're tapping phone lines, I know that that ain't allowed.
---------:---------:---------:---------:---------:---------:---------:----
Timothy C. May              | Crypto Anarchy: encryption, digital money,
<EMAIL_ADDRESS>408-728-0152 | anonymous networks, digital pseudonyms, zero
W.A.S.T.E.: Corralitos, CA  | knowledge, reputations, information markets,
Higher Power: 2^1,257,787-1 | black markets, collapse of governments.
"National borders aren't even speed bumps on the information superhighway."

{% endraw %}
```

## Thread

+ Return to [October 1996](/archive/1996/10)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to<EMAIL_ADDRESS>(Steve Schear)](/authors/azur_at_netcom_com_steve_schear_)"
+ Return to "[Black Unicorn <unicorn@schloss.li>](/authors/black_unicorn_unicorn_at_schloss_li_)"
+ Return to "[David Lesher <wb8foz@nrk.com>](/authors/david_lesher_wb8foz_at_nrk_com_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to "[Lucky Green <shamrock@netcom.com>](/authors/lucky_green_shamrock_at_netcom_com_)"
+ Return to "[Ray Arachelian <sunder@brainlink.com>](/authors/ray_arachelian_sunder_at_brainlink_com_)"
+ Return to<EMAIL_ADDRESS>(Roy M. Silvernail)](/authors/roy_at_sendai_scytale_com_roy_m_silvernail_)"
+ Return to "[Scott McGuire <svmcguir@syr.edu>](/authors/scott_mcguire_svmcguir_at_syr_edu_)"
+ Return to "["Timothy C. May" <tcmay@got.net>](/authors/timothy_c_may_tcmay_at_got_net_)"

+ 1996-10-06 (Mon, 7 Oct 1996 07:12:09 +0800) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/07bad45dfc02d7277b31fa50a73c5b7624fa02afc8cb595a7b3cfcc767737544) -<EMAIL_ADDRESS>(Steve Schear)_
  + 1996-10-07 (Mon, 7 Oct 1996 10:25:22 +0800) - Re: "Drift net fishing," GAK, FBI, and NSA - _"Timothy C. May"<EMAIL_ADDRESS>    + 1996-10-07 (Mon, 7 Oct 1996 13:32:58 +0800) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/d1377150ab6149c75b472b8d179ddc70fea186bd8fcc06c7b3f7023387447bcc) - _Black Unicorn<EMAIL_ADDRESS>      + 1996-10-07 (Tue, 8 Oct 1996 01:43:21 +0800) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/026f5da816eb963ff6d40088418457d1b0cd73545fca95184202a2f6b4286650) - _David Lesher<EMAIL_ADDRESS>        + 1996-10-07 (Tue, 8 Oct 1996 04:42:10 +0800) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/57371f9dbb22cf44400902f2f1fc1c672946262b301d042ef20c5b04c7bb265d) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_
          + 1996-10-09 (Wed, 9 Oct 1996 10:34:11 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/d55eead364ed62fdd157725ffcb18f2ff91c94e83c394c45120088c15746b24e) - _Adam Back<EMAIL_ADDRESS>            + 1996-10-10 (Thu, 10 Oct 1996 05:43:54 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/6a45def4e1e55241e1c0d1f5bbceb8cd38418c21e7a54afbc059218b51baab2f) -<EMAIL_ADDRESS>(Roy M. Silvernail)_
              + 1996-10-10 (Thu, 10 Oct 1996 15:45:47 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/389a35eb5074c053a06cc66656568b0b12c3ebab34e0ad539f8f684d832f3b1d) - _Scott McGuire<EMAIL_ADDRESS>                + 1996-10-11 (Fri, 11 Oct 1996 07:42:37 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/12b43453b01ea37e6622f0ddc3d04292602772bee12b113941afcfb60d2f7bc6) -<EMAIL_ADDRESS>(Roy M. Silvernail)_
                  + 1996-10-12 (Fri, 11 Oct 1996 21:26:37 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/96087484e456f1801f8a136653d3c85dd6a602e0915ad20e9ef8799b039649ac) - _Ray Arachelian<EMAIL_ADDRESS>                  + 1996-10-14 (Mon, 14 Oct 1996 04:59:19 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/c82e13a298ec361d25865d731c79cb7566f5dc6d10a88b9de9e19a0e0315fed6) - _Black Unicorn<EMAIL_ADDRESS>                    + 1996-10-15 (Mon, 14 Oct 1996 17:42:27 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/2b3584e60f61f47a9a8c60289f11bc10d10ec53714191de00f027e6208d823a4) -<EMAIL_ADDRESS>(Roy M. Silvernail)_
                      + 1996-10-15 (Mon, 14 Oct 1996 19:27:10 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/c4347f807802347a826ced747c70db048e255786e618907955c39aae9bb1281a) - _Lucky Green<EMAIL_ADDRESS>          + 1996-10-11 (Thu, 10 Oct 1996 21:30:12 -0700 (PDT)) - [Re: "Drift net fishing," GAK, FBI, and NSA](/archive/1996/10/536b07a7a1ab5d9dd13891263163e7381e464ec6d5fd2e8aa0229364204cc27f) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_


text:
# Contributing guide

If you are reading this, you may be  to contribute. Just for that, a big thank you ! 👏

Feel free to propose pull requests, or open new [discussions](https://github.com/hubblo-org/scaphandre/discussions) or [issues](https://github.com/hubblo-org/scaphandre/issues) at will. Scaphandre is a collaborative project and all opinions and propositions shall be heard and studied. The contributions will be received with kindness, gratitude and with an open mind. Remember that we are all [dwarfs standing on the shoulders of giants](https://en.wikipedia.org/wiki/Standing_on_the_shoulders_of_giants). We all have to learn from others and to give back, with due mutual respect.
### Code of conduct

This project adheres to the Rust Code of Conduct, which [can be found here](https://www.rust-lang.org/conduct.html).
### Ways to contribute

Contributions may take multiple forms:
- 💻 **code**, of course, but not only (there is a lot more !)
- 📖 **documentation**
- 🎤 Any help on **communication**: writing blog posts, speaking about scaphandre in conferences, speaking and writing about the responsibility of tech to be sustainable as well !
- 🧬 **structuring the project** and the **community** is also a very important topic. Feel free to propose help, or start [discussions](https://github.com/hubblo-org/scaphandre/discussions) about that.

This project intends to unite a lot of people to have a lot of positive impact. Any action going helping us to get there will be very much appreciated ! 🎉
### Contact

Discussions and questions about the project are welcome on [gitter](https://gitter.im/hubblo-org/scaphandre?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) or by [email](mailto://bpetit@hubblo.org?Subject=About%20Scaphandre).
### Contribution guidelines

This project intends to use [conventionnal commit messages](https://conventionalcommits.org/) and the [gitflow](https://nvie.com/posts/a-successful-git-branching-model/) workflow.

Scaphandre is a not only a tool, but a framework. Modules dedicated to collect energy comsumption data from the host are called [**Sensors**](docs/sensors).
Modules that are dedicated to send this data to a given channel or remote system are called [**Exporters**](docs/exporters). New Sensors and Exporters are going to be created and all contributions are welcome. For more on the internal structure please jump [here](explanations/internal-structure.md).

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
---
id: pysa-tips
title: Development Tips
sidebar_label: Development Tips
---

## Features/Limitations

### Inheritance

Pysa is aware of inheritance, so you can add taint annotations to a base class,
and Pysa will detect when the tainted attribute or function is accessed via a
child class. For example, this flow will be detected during static analysis:

```python
class Parent:
    def some_source(self): # Annotated as a source
        pass

class Child(Parent):
    pass

child = Child()
some_sink(child.some_source()) # Detected as a tainted flow
```

Additionally, Pysa is aware that child classes can be used anywhere a parent
classes's type is present. If you access a method on a parent class and the
implementation on any child class returns taint, Pysa will detect that and
treat the return from the parent class as tainted. For example, this will be
detected as a tainted flow during static analysis:

```python
class Parent:
    def some_fn(self):
        """Benign function with no annotations"""
        pass

class Child(Parent):
    def some_fn(self):
        """Function returning a tainted value"""
        return get_some_tainted_value()

def fn(obj: Parent):
    some_sink(obj.some_fn()) # Detected as a tainted flow
```

**A huge caveat here is that Pysa needs to be aware of these inheritance
relationships and function definitions for it to work.** Code that lives
outside the repo under analysis might not be visible to Pysa, so these
inheritances/implementations may be missed. See the Stubs section below for
more details.

### Stubs

The concept of stubs is covered in general _[here](pysa_basics.md)_, but this
section in particular will cover specific issues you may encounter with the
`.pyi` kind of stubs. These stubs can be used to prevent pyre errors for types
that live outside the codebase you are running Pysa on. The simplest stubs are
just empty files in the root of the `stubs` directory (assuming you have a
`stubs` directory specified in the `search_path` list in your
`.pyre_configuration` file). An empty stub basically prevents all type checking
errors within the namespace of that stub. So for `uwsgi.pyi`, in the `stubs`
directory, the following code would not raise pyre errors (though it would
obviously fail to run):

```python
import uwsgi
from uwsgi import asdf, ZXCV
uwsgi.qwer()
variable = ZXCV()
variable.hjkl()
```

If you want to be able to create `.pysa` stubs (i.e. annotate sources, sinks,
etc.) for something that is outside your codebase, such as Django's
`django.http.request.HttpRequest` object, you need more than just an empty stubs
file. You need a directory structure and `.pyi` file that matches your import,
such as `stubs/django/http/request.pyi`. Within that `.pyi` file, you
then need a stub of the class:

```python
class HttpRequest(BinaryIO):
    def __init__(self) -> None: ...
    COOKIES: Any = ...
    GET: QueryDict = ...
    # And a bunch more stuff...
```

Only at this point can you add `.pysa` files with annotations such as these:

```
django.http.request.HttpRequest.COOKIES: TaintSource[UserControlled] = ...
django.http.request.HttpRequest.GET: TaintSource[UserControlled] = ...
```

**There is a huge gotcha here**: If you had both an empty `stubs/django.pyi`
file, and the `stubs/django/http/request.pyi` file shown above, pyre will see
the `django.pyi` file first and ignore the `request.pyi` file. This would mean
that your stub of `HttpRequest` would be missed, and your `HttpRequest.COOKIES`
and `HttpRequest.GET` annotations would cause errors when running Pysa. The fix
is simply to delete the `django.pyi` file. When deleting that file, you may all
of a sudden see new typing errors for other types within Django, for which
you'll need to add new .`pyi` files at the appropriate locations.

### Missing types cause missed flows

Due to optimizations to allow parallelization, Pysa can be blind in some
scenarios that might be obvious to a human. Pysa needs to know the type of an
object that is a source/sink *at the point at which it is accessed*, in order
for it to detect tainted flows. For example, if you have a function that returns
a wrapper around a source, flows from that source will not be found unless the
return type of the function is specified. See below how one of the flows in the
`run` function is missed, simply because the return type on
`get_wrapper_untyped` is missing:

```python
from django.http import HttpRequest
class RequestWrapper:
    request: HttpRequest
    def __init__(self, request: HttpRequest):
        self.request = request

    @property
    def get_request_data(self):
        return self.request.GET["data"]

def get_wrapper_untyped(request: HttpRequest):
    return RequestWrapper(request)

def get_wrapper_typed(request: HttpRequest) -> RequestWrapper:
    return RequestWrapper(request)

def run(request: HttpRequest):
    # This flow WILL NOT be found
    wrapper = get_wrapper_untyped(request)
    eval(wrapper.get_request_data)
    # This flow WILL be found
    wrapper = get_wrapper_typed(request)
    eval(wrapper.get_request_data)
```

This illustrates how important typing is for ensuring all flows are caught by
during static analysis.

## Helpful Python knowledge

Pretty much all python operators are reduced down to double underbar functions.
For example, constructing an object results in a call to `__init__(self, ...)`
and an asterisk operator results in a call to `__mul__(a, b)`. A full list of
these operators can be found
[here](https://docs.python.org/3.7/library/operator.html). This is useful to
know when you need to add annotations to the usage of operators, such as the use
of square brackets to access a dictionary.

## Debugging Tools

### `pyre_dump()`

You can insert a call to the (non-existent) `pyre_dump()` function in your code
to trigger to pyre to output a ton of metadata about it's current state when it
parses the that function call. This can be useful as a starting point to figure
out why something is/isn't happening. This will produce *very* verbose output.

### `reveal_type(info)`

If you only want to check what pyre knows about the types of variables, you can
call `reveal_type(YOUR_VARIABLE)` on the variable and then run pyre on the code
to get much less verbose output than `pyre_dump()`.

### Detecting Taint

There is no direct way to know if Pysa has detected a variable as tainted or
not. One simple way to do this is inject a call to a known sink for your source,
such as `eval`. You would pass the object that you want to know about into the
sink, run Pysa, and see if the flow is detected.

Another strategy for getting a bit more metadata is adding a function into your
code, which simply constructs and returns the type you want to examine. You can
then run Pysa, and grep for the function's name in the
`results.json` file located wherever you pointed `--save-results-to=` to when
running Pysa. You should then be able to see if that function is detected as
returning taint, plus a bit more metadata about it.

license: MIT

repository: MedRedha/pyre-check

branch_name: refs/heads/master

gha_license_id: MIT

repo_name: MedRedha/pyre-check


text:
# Google Books Search & Save
![Badge for MIT](https://img.shields.io/badge/license-MIT-green)
![Deployed Link](https://alison-google-books.herokuapp.com/)

## Description
Search for books using the googlebooks API, then save your favorites. This app was built with React.

## Table of Contents
* [Installation](#installation)
* [Usage](#usage)
* [Screenshot](#screenshot)
* [License](#license)
* [Contributing](#contributing)
* [Tests](#tests)
* [Questions](#questions)

## Installation
Install npm packages as usual.

## Usage
After installing npm packages, launch the app. Type part of a title in the search bar, and choose from a list of relevant results to save.

## Screeshots
![Screenshot forthcoming](./readmeImages/screenshot.png)

## License
MIT License

    Copyright (c) 2021 Alison Lubar

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

     IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.

## Contributing
Help from instructor Anthony, TA Tom, & tutor Meguel.

## Tests
None, for now.

## Questions
Find me on GitHub here: https://github.com/theoriginalison
or you can reach me at<EMAIL_ADDRESS>for any additional questions.

repository: theoriginalison/google-books

repo_name: theoriginalison/google-books


text:
---
key: "plugins--excerpt-sample"
---

I am part of the excerpt.

You can use any feature in excerpts *bold* text, __underlined__ text and custom containers:

::: tip
I am a container and part of the excerpt.
:::

And even custom components:

<MpSampleButton>Test</MpSampleButton>

<!-- more -->

I am the main content

repository: ChristianKienle/minipress

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: ChristianKienle/minipress


text:
# How to Contribute

First of all, start the Storybook Hub Backend and get logged in.

> Storybook Hub Backend is a private app and we'll update how to setup this addon for development without that dependency.

Then start the storybook inside this app.

```sh
npm run storybook
```
Now you'll see a comments tab and you can start contrubuting.

repository: storybook-eol/storybook-addon-comments

repo_name: storybook-eol/storybook-addon-comments


text:
Machine Learning Methods
========================

Our number one concern is speed of deployment, as we do not want to get bogged down in the theory of machine learning; that could take months or years to understand and implement.

As such, we chose to use an off-the-shelf solution. We considered several options, such as `SmileMiner` (Java), `Apache Spark` (Scala, Java, Python) and `Orange` (Python), however, we chose to use `scikit-learn` for the following reasons:

- It is in Python, so it is accessable to any member of the team
- It is a mature, well-supported and fully-featured library
- It has support for on-line learning models

We are using scikit-learn's `SGDClassifier` class, for which the documentation is [here](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html). We train it with two classes, whether a user is "interested" or "not interested" in that article. The inputs are:

- A measure of the similarity in topics between the article and the user's interests (from `kw_score.py`)
- The number of seconds between the article being published, and the user looking at it (ie. In training, the number of seconds between the article publish and the user vote, in prediction, the number of seconds between the article publish and the current time).

If a user upvotes an article, these inputs are mapped to a value of 1. If they downvote an article, these inputs are mapped to a value of -1.

When we add some data to the model, it is pickled and put in the `user` db collection. This is done by the `update-user-model` Gearman worker.

repository: waffle-iron/feedlark

repo_name: waffle-iron/feedlark


text:
# SJSU GameDev Arcade Launcher
An arcade launcher, similiar to the Winnitron launcher, but open source and released under the MIT license.

# launcherConfig.json
In order for the launcher to work, it must have a configuration file named launcherConfig.json

```
{
    // This is for when you want an arcade machine to display
    // a subset of the games available.
    "presetList" :
    [
        {
            // Give the preset a name
            "presetName": "Action",
            // And a list of ID's
            "gameList": ["TurtlesInTime", "Contra""]
        }
    ],

    "gameList" :
    [
        {
            // A clean, short, and unique ID with no spaces.
            "gameId": "TurtlesInTime",
            // The full name to be displayed on the machine.
            "gameName": "Teenage Mutant Ninja Turtles: Turtles In Time",
            // Short description of the game to be displayed.
            "gameDescription: "Teenage Mutant Ninja Turtles: Turtles in Time, released as Teenage Mutant Hero Turtles: Turtles in Time in Europe, is an arcade video game produced by Konami",
            // List of authors of the game to be displayed.
            "gameAuthor": "Konami", "Mutsuhiko Izumi", "Kozo Nakamura",
            // Path to the game relative to this file.
            "executablePath" : "_gameData/tmnt/game/tmnt.exe",
            // Path to a screenshot relative to this file.
            "screenshotName" : "_launcherData/kiss_screenshot.png"
        }
    ]
}
```

## License

    The MIT License (MIT)

    Copyright (c) 2014 Henry Tran

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.

     IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    THE SOFTWARE.

repository: qwook/SJSUArcadeLauncher

repo_name: qwook/SJSUArcadeLauncher


text:
# SwiftyDijkstra

Example _Dijkstra_ algorithm (shortest path problem) implementation written in Swift.

## Usage

![Example usage](https://raw.githubusercontent.com/username0x0a/SwiftyDijkstra/master/example.png)

```swift
import Foundation
import SwiftyDijkstra

// Define the nodes

let Brno = Node("Brno")
let Praha = Node("Praha")
let Ostrava = Node("Ostrava")
let Pardubice = Node("Pardubice")
let Kolin = Node("Kolin")
let Plzen = Node("Plzen")

// Define the graph edges

var edges = [
	Edge(from: Ostrava, to: Brno, cost: 180),
	Edge(from: Praha, to: Ostrava, cost: 420),
	Edge(from: Pardubice, to: Brno, cost: 110),
	Edge(from: Pardubice, to: Praha, cost: 90),
	Edge(from: Pardubice, to: Plzen, cost: 140),
	Edge(from: Pardubice, to: Ostrava, cost: 290),
	Edge(from: Plzen, to: Praha, cost: 70),
]

// Initialize the graph itself

var G = Graph(edges: edges)

// Look for shortest paths and print'em

print(G.shortestPath(from: Praha, to: Ostrava))
// outputs [Praha, Pardubice, Ostrava]
print(G.shortestPath(from: Ostrava, to: Plzen))
// outputs [Ostrava, Pardubice, Plzen]
print(G.shortestPath(from: Ostrava, to: Ostrava))
// outputs [Ostrava]
print(G.shortestPath(from: Brno, to: Kolin))
// outputs []

```

## License

Dijkstra example is released under the MIT license. See the LICENSE file for details.


text:
Adafruit Python DHT Sensor Library
==================================

````
sudo apt-get update
sudo apt-get install build-essential python-dev
````

Install the library by downloading with the download link on the right, unzipping the archive, and executing:

````
sudo python setup.py install
````

See example of usage in the examples folder.

<<<<<<<<<<<<<Run it for Sensor model 22 connected sensor pin 13>>>>>>>>>>>>>>

!!!!!!!!!!!!!!!!!!!!!!!!!!!
sudo ./AdafruitDHT.py 22 13
!!!!!!!!!!!!!!!!!!!!!!!!!!!

Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!

Written by Tony DiCola for Adafruit Industries.

MIT license, all text above must be included in any redistribution


text:
---
title: CallBuilder
---

## Overview

`CallBuilder` is a class that allows specificity and flexibility when querying the Horizon server.  By using the [Builder Pattern](https://en.wikipedia.org/wiki/Builder_pattern), `CallBuilder` provides methods that can be chained together to generate a query.

## Options

| Method | Param Type | Description |
| --- | --- | --- |
| `limit(limit)` | `integer` | Limits the number of returned resources to the given `limit`.|
| `cursor("token")` | `string` | Return only resources after the given paging token. |
| `order({"asc" or "desc"})` | `string` |  Order the returned collection in "asc" or "desc" order. |
| `call()` | | Triggers a HTTP Request to the Horizon server based on the builder's current configuration.  Returns a `Promise` that resolves to the server's response.  For more on `Promise`, see [these docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).|
| `stream({options})` | object of [properties](https://developer.mozilla.org/en-US/docs/Web/API/EventSource#Properties) | Creates an `EventSource` that listens for incoming messages from the server.  URL based on builder's current configuration.  For more on `EventSource`, see [these docs](https://developer.mozilla.org/en-US/docs/Web/API/EventSource). |

## Examples

Let's say you want to look at 20 transactions for an account with the address "GSDEF".  You don't want the latest 20; instead, you want the 20 after the paging token "2354-4".  Finally, you want the server response to be returned in the form of a `Promise`.

So, you take the [`server` object](./server.md) and start with

```
server.transactions()
```

which returns a `TransactionCallBuilder`, an extension of the `CallBuilder` class.

Then you specify the address you want with `.forAccount()`, a method provided by `TransactionCallBuilder`.

```
server.transactions()
  .forAccount("GSDEF")
```

You want only 20 transactions, so you can chain `.limit("20")`.  But you also want only transactions after a particular paging token, so you add `.cursor("2354-4")`.    Only `call()` and `stream(options)` does that.  You want the result to be a `Promise`, so you choose `call()`.

```
server.transactions()
  .forAccount("GSDEF")
  .limit("20")
  .cursor("2354-4")
  .call()
```

repository: Smartlands-Platform/Wallet

repo_name: Smartlands-Platform/Wallet


text:
# PasswordKeeper - BackEnd

Training project in Node JS, Express and other technologies Back End.

Project under development.

## Build With

* NodeJS
* Express
* Sequelize
* PostgreSQL
* Webpack

## Versioning

I use [SemVer](https://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/RNunes13/pwdkeeper-back/tags).

## Authors

* **Rodrigo Nunes** - Initial work - [RNunes](https://github.com/RNunes13)

## License

This project is licensed under the MIT License - see the LICENSE file for details.

gha_language: TypeScript


text:
# CSS Notes
Some notes on CSS. These notes are from various sources such as
MDN, Chrome developer, etc., these notes are not mine.

## 2D Transformations
Look at transformations.html
* translate
* rotate
* scale
* skew

## 3D Transformations
Look at transformations3d.html
* perspective
  * this css property determines the distance between the z=0 plane and the user in order to give a
  a 3D-positioned element some perspective. Each 3D element with z>0 becomes larger; each 3D element
  with z<0 becomes smaller. The strength of the effect is determine by the value of this property.
  * please note that the perspective property doesn't affect how the element is rendered; it simply enables
  a 3D-space for children elements. this is the main difference between the transform: perspective() function
  and the perspective property. The first gives element depth while the later creates a 3D-space shared by all
  its transformed children.
  * if you use the perspective function on multiple elements the effect breaks. The transformed elements don't
  line up together. This is because each element has its own perspective, its own vanishing point. To remedy this
  use the perspective property on the parent element.
* 3D transform functions
  * rotateX()
  * rotateY()
  * rotateZ()
  * translateZ() - positions the element along the z-axis, which runs front to back in 3D space. Positive values position
  the element closer to the viewer, negative values further away.
  * scaleZ()
* shorthand transform functions - these 3 arg transform3d() functions also have the benefit of triggering hardware
acceleration.
  * translate3d(tx, ty, tz)
  * scale3d(sx, sy, sz)
  * rotate3d(rx, ry, rz)
* Pattern for any 3D transform: keeping the 3d space element and the object seperate element establishes a paradigm that is
simple to understand and easier to style.
  * scene
  * object
  * faces
* `preserve-3d`
  * an element's perspective only applies to direct descendant children. In order for subsequent children to inherit a
 parent's perspective, and live in the same 3d-space, the parent can pass along its perspective with `transform-style: preserve-3d`.
* `backface-visibility`
  * in transformation3d.html, in the card flip example, this is used to hide the back-side of the faces when they are
    faced away from the viewer.
* `transform-origin`
  * by default, the tranform origin of an element is at its horizontal and vertical center (50% 50% or center center)
  * an element's transforms are applied from its transform-origin

## Transitions
Look at transitions.html
* shorthand: `transition: <property> <duration> <timing-function> <delay>`
* JavaScript
  * **Care should be taken when using a transition immediately after**:
    * adding the element to the DOM using .appendChild()
    * removing an element's `display: none;` property
  * this is treated as if the initial state had never occurred and the element was always in its final state. the easy way
  to overcome this limitation is to apply  `window.setTimeout()` of a handful of ms before changing the CSS property you
  intent to transition to.

## CSS Gradients
Look at cssGradients.html
CSS gradients are represented by the `<gradient>` data type, a special type of `<image>` made of a progressive transition
between two or more colors. You can choose between 3 gradient types:
1. *linear* - created with the `linear-gradient()` function
2. *radial* - created with the `radial-gradient()` function
3. *conic* - created with the conical-gradient function

You can also create repeating gradients with the `repeating-linear-gradient()` and `repeating-radial-gradient()` functions.

## CSS Filters
* Right now filters apply to the whole element and all its descendants.
* Though CSS filters encompass a huge range of possibilites, the most common usage will be the canned effects,
namely grayscale, sepia, saturate, hue-rotate, invert, opacity, brightness, contrast, blue, and drop-shadow.
* syntax
  * `grayscale(0)`
  * `sepia(0)`
  * `saturate(1)`
  * `hue-rotate(0deg)`
  * `invert(0)`
  * `opacity(1)`
  * `brightness(1)`
  * `contrast(1)`
  * `blur(0px)`
  * `drop-shadow()` - same values as box-shadow
* `drop-shadow`
  * Its awesome
  * Why? lets say you have a png, if you use drop-shadow on the img element, its going to give a shadow to the img box however, if you use the css filter, it will give a shadow to the png itself, which looks awesome.

## @keyframes
* `animation-timing-function`
  * Note: **this is the only property that can be included within keyframe declarations.**
* `animation-direction`
  * sometimes you want animations to behave like transitions: when you transition on hover, the animation reverses on mouse out. Setting this property to `alternate`, every other animation can be set to go from 100% to 0%.
* `animation-delay`
  * *If you want animation to begin halfway through the animation, include an `animation-delay` value that is negative. For example, if you have a 10s animation, including an `animation-delay: 5s;` will cause the animation to start immediately, starting half way through the animation.*
* animation shorthand
  * `animation: <name> <duration> <timing-function> <delay> <iteration-count> <direction> <fill-mode>;`
* `animation-fill-mode`
  * takes one of four values: **backwards, forwards, none or both, with default being none**
  * **backwards**: makes the element go directly to keyframe 0% when they page loads, even if there is an `animation-delay`, staying there until the animation starts
  * **forwards**: tells the browser to stop the animation on the last keyframe at the end of the last iteration and not revert back to its pre-animation state.
  * **both**: applies both backwards and forwards

## Request Animation Frame
Look at requestAnimationFrame.html
* Frame rate anf setInterval
  * the smoothness of your animation depends on the frame rate of your animation
  * frame rate is measured in frames per second (fps). film usually runs at 24fps, video at 30fps. The higher this number is, the smoother your animation will look...to a point. More frames, means more processing, which can often cause stuttering and skipping. This is what is meant by the term dropping frames. Because most screens have a refresh rate of 60Hz, the fastest frame rate you should aim for is 60 fps.
  * *1000ms / 60 (fps) = 16.7ms ~ 17*
* Whats wrong with setTimeout and setInterval
  * First `setTimeout` doesn't take into account what is happening in the browser. The page could have hidden behind a tab, hogging your CPU when it doesn't need to, or the animation itself could have been scrolled off the page making the update call again unnecessary. Chrome does throttle `setInterval` and `setTimeout` to 1fps in hidden tabs, but this isn't to be relied upon for all browsers.
  * Secondly `setTimeout` only updates the screen when it wants to, not when the computer is able to. That means your poor browser has to juggle redrawing the animation whilst redrawing the whole screen, and if your animation frame rate is not synchronized with the redrawing of your screen, it could take up more processing power. That means higher CPU usage and your computer's fan kicking in, or draining the battery on your mobile device.
  * Another consideration is the animation of multiple elements at once. One way to approach this is to place all the animation logic in one interval with the understanding that animation calls may be running even though a particular element may not require any animation for the current frame. The alternative is to use seperate intervals. The problem with this approach is that each time you move something on the screen, your browser has to repaint the screen. This is wasteful.
* `requestAnimationFrame`
  * To overcome these efficiency problems, Mozilla proposed the `requestAnimationFrame` function, which was later adopted and improved by the WebKit team. *It provides a native API for running any type of animation in the browser, be it using DOM elements, CSS, canvas, WebGL, or anything else.
  * The key difference here is that you are requesting the browser to draw your animation at the next available opportunity, not at a predetermined interval. It has also been hinted that browsers could choose to optimized performance of `requestAnimationFrame` based on load, element visibility (being scrolled out of view) and battery status.
  * The other beauty of `requestAnimationFrame` is that it will group all of your animations into a single browser repaint.
  * What if I want to set a frame rate ?
    * One technique would be to check the number of ms past since that last draw call and update the animation's position based on the time difference.
* Game Dev
  * `requestAnimationFrame` vs user input
    * Events can cause work whenever ex: Timers, DOM input handlers, non contiguous work, so -> **buffer your inputs and handle in RAF(`requestAnimationFrame`)

## Fullscreen API
Look at fullscreenAPI.html
The Fullscreen API adds methods to present a specific Element (and its descendants) in fullscreen mode, and to exit full-screen mode once it is no longer needed.

## CSS media queries
Media queries are useful when you want to modify your site or app depending on a device's general type
(such as print vs screen) or specific characteristics and parameters (such as screen resolution or browser
viewport width).
Media queries are used for the following:
* To conditionally apply styles with the CSS `@media` and `@import` at-rules
* To target specific media for the `<link>`, `<source>`, and other html elements.
* To test or monitor media states using the `Window.matchMedia()` and `MediaQueryList.addListener()`
javascript methods.

* Media Types - describe the general category of a device. Except when using the `not` or `only` logical
operators, the media type is optional and the `all` type will be implied.
  * `all` - suitable for all devices
  * `print` - intended for paged material and documents viewed on a screen in print preview mode.
  * `screen` - intended primarily for screens
  * `speech` - intended for speech synthesizers

* Media Features - describe specific characteristics of the user agent, output device, or environment. Media
feature expressions test for their presence or value, and are entirely optional. Each media feature expression
must be surrounded by parenthesis. Here are some:
  * `width`
  * `height`
  * `aspect-ratio`
  * `orientation`
  * `hover`
  * `scripting` - detectes whether JS is available

* Logical Operators - The logical operators `not`, `and`, and `only` can be used to compose a complex media
query. You can also combine multiple media queries into a single rule by seperating them with commas.

Syntax improvements in level 4
* `@media (max-width: 30em) {...}` -> `@media (width <= 30em) {...}`
* `@media (min-width: 30em) and (max-width: 50em) {...}` -> `@media (30em <= width <= 50em ) { ... }`
* Negating a feature with `not` ex: `@media (not(hover)) {...}`, this says if device has no hover capability
* Testing for multiple features with `or`

Media Queries for Standard Devices
* You should not base your breakpoints on devices!!
* Choosing breakpoints based on your design and not specific devices is a smart way to go.

## CSS Flex
Note: Flexbox layout is most appropriate to the components of an application, and small-scale layouts,
while the Grid layout is intended for larger scale layouts.

* Properties of the parent (flex container)
  * `display`: flex | inline-flex
  * `flex-direction`: row | row-reverse | column | column-reverse
  * `flex-wrap`: nowrap | wrap | wrap-reverse
  * `flex-flow`: <'flex-direction'> || <'flex-wrap'>
  * `justify-content`: flex-start (default) | flex-end | center | space-between | space-around
    space-evenly | start | end | left | right ... + safe | unsafe
      * This defines the alignment along the main axis. It helps distribute extra free space leftover
        when either all the flex items on a line are inflexible, or are flexible but have reached their
        maximum size. It also exerts some control over the alignment of items when they overflow the
        line.
      * Note that the browser support for these values is nuanced. For example, `space-between` never
        got support from some versions of Edge, and start/end left/right aren't in Chrome yet. The
        safest values are `flex-start`, `flex-end`, and `center`.
      * There are also two additional keywords you can pair with these values: `safe` and `unsafe`.
        Using `safe` ensures that however you do this type of positioning, you can't push an element
        such that it renders off-screen (e.g. off the top) in such a way the content can't be scrolled
        too (called "data loss").
  * `align-items`: stretch (default) | flex-start | flex-end | center | baseline | first baseline
    last baseline | start | end | self-start | self-end + ... safe | unsafe
    * This defines the default behavior for how flex items are laid out along the cross axis on the
      current line. Think of it as the `justify-content` version for the cross axis (perpendicular
      to the main axis).
  * `align-content`: flex-start | flex-end | center | space-between | space-around | space-evenly
    stretch (default) | start | end | baseline | first baseline | last baseline + ... safe | unsafe
    * This aligns a flex container's lines within when there is extra space in the cross-axis,
      similar to how `justify-content` aligns individual items within the main-axis.
    * Note: this property has no effect when there is only one line of flex items.

* Properties for the children (flex items)
  * `order`: integer;
    * By default, flex items are laid out in the source order. However, the order property
      controls the order in which they appear in the flex container.
  * `flex-grow`: number
    * This defines the ability for a flex item to grow if necessary. It accepts a unitless value
      that serves as a proportion. It dictates what amount of the available space inside the flex
      container the item should take up.
    * If all items have `flex-grow` set to 1, the remaining space in the container will be distributed
      equally to all children. If one of the children has a value of 2, the remaining space would take
      up twice as much space as the others (or will try to at least).
    * Negative numbers are invalid.
  * `flex-shrink`: number
    * this defines the ability for a flex item to shrink if necessary. Negative numbers are invalid.
  * `flex-basis`: length | auto
    * This defines the default size of an element before the remaining space is distributed. It
      can be a length (e.g. 20%, 5rem, etc.) or a keyword. The `auto` keyword means "look at my
      width or height property". The `content` keyword means "size it based on the item's content",
      this keyword isn't well supported yet, so it's hard to test and harder to know what its
      brethen `max-content`, `min-content`, and `fit-content` do.
    * If set to 0, the extra space around content isn't factored in. If set to `auto`, the extra
      space is distributed based on its `flex-grow` value.
  * `flex`: none | [ <'flex-grow'> <'flex-shrink'>? || <'flex-basis'>]
    * This is shorthand for `flex-grow`, `flex-shrink`, and `flex-basis` combined. The 2nd and 3rd
      parameters are optional. The default is `0 1 auto`, but if you set it with a single number
      value, it's like `<number> 1 0`.
    * **It is recommended that you use this shorthand property** rather than set the individual
      properties. The shorthand sets the other values intelligently.
  * `align-self`: auto | flex-start | flex-end | center | baseline | stretch
    * This allows the default alignment (or the one specified by `align items`) to be overriden
      for individual flex items.
    * Note that `float`, `clear`, `vertical align` have no effect on a flex item.

## CSS Grid
Look at cssGrid.html
* Properties for the parent (Grid Container)
  * `grid-auto-columns, grid-auto-rows`
    * specifies the size of any auto-generated grid tracks (aka implicit grid tracks). Implicit tracks get
    created when there are more grid items than cells in the grid or when a grid item is placed outside of
    the explicit grid.
    * `minmax()` - lets us set a min and max size for a track, for ex: `minmax(100px, auto)`. The min size is 100px, but
      the max is `auto`, which will expand to fit the content.
  * `grid-auto-flow`
    * if you have grid items that you don't explicitly place on the grid, the *auto-placement-algorithm* kicks
    in to automatically place the items. This property controls how the auto-placement algorithm works.
    * values
      * row - tells the auto-placement algorithm to fill in each row in turn, adding new rows as necessary (default)
      * column - tells the auto-placement algorithm to fill in each column in turn, adding new columns as necessary
      * dense - tells the auto-placement algorithm to attempt to fill in holes earlier in the grid if smaller items
        come up later Note: dense only changes the visual order of your items and might cause them to appear out of order,
        which is bad for accessibility.
  * As many columns as will fit - sometimes it is helpful to be able to ask grid to create as many columns as will fit into
    the container. We do this like this: `grid-template-columns: repeat(auto-fill, minmax(200px, 1fr))`
* Properties for the Children (Grid Items)
  * `grid-column-start, grid-column-end, grid-row-start, grid-row-end`
    * determines a grid item's location within the grid by referring to specific grid lines.
    * `grid-column-start/grid-row-start` - is the line where the item begins
    * `grid-column-end/grid-row-end` - is the line where the item ends
    * values
      * `<line>` - can be a number to refer to a numbered grid line, or a name to refer to a named grid line
      * `span <number>` - the item will span across the provided number of grid tracks
      * `span <name>` - the item will span across until it hits the next line with the provided name
      * `auto` - indicates auto-placement, an automatic span, or a default span of one
    * if no `grid-column-end/grid-row-end` is declared, the item will span 1 track by default
    * items can overlap each other. You can use z-index to control their stacking order.
  * `grid-column, grid-row` - shorthand for `grid-column-start` + `grid-column-end`, and `grid-row-start` + `grid-row-end`
    * values
      * `<start-line>/<end-line>` - each one accepts all the same values as the longhand version, including span
    * You can also use the value `-1` to target the end column or row line, and count inwards from the end using negative
      values. However this only works for the explicit grid. The value `-1` will not target
  * `grid-area` - gives an item a name so that it can be referenced by a template created with the `grid-template-areas` property. Alternatively,
    this property can be used as an even shorter shorthand for `grid-row-start` + `grid-column-start` + `grid-row-end` + `grid-column-end`
    * values
      * `<name>` - a name of your choosing
      * `<row-start>/<column-start>/<row-end>/<column-end>` can be numbers or named lines
  * `justify-self` - aligns a grid item inside a cell along the *inline(row)* axis.  This value applies to the content inside a single grid item. values: start, end, center, stretch

## CSS Pseudo-classes
* `:active` - represents an element (such as a button) that is being activated by the user. When using a mouse, activation typically starts when the user presses down the primary mouse button.
* `:checked` - represents any radio (`<input type="radio">`), checkbox(`<input type="checkbox"`), or option(`<option>` in a `<select>`) element that is checked or toggled to an on state.
* `:default` - represents any form element that is the default among a group of related elements.
  * this selector may be used on the `<button>, <input type="checkbox">, <input type="radio"> and <option> elements`.
* `:dir()` - matches elements based on the directionality of the text contained in them.
  * ex:
  `:dir(rtl) { background-color: red }`
  * params: ltr, rtl
  * the `:dir()` pseudo-class uses only the semantic value of the directionality, the one defined in the document itself. It doesn't account for styling directionality, the directionality set by CSS properties such as `direction`.
* `:disabled` - represents any disabled element. An element is disabled if it can't be activated (selected, clicked on, typed into, etc) or accept focus. The element also has an enabled state, in which it can be activated or accept focus.
* `:empty` - represents any element that has no children. Children can be either element nodes or text (including whitespace).
* `:enabled` - represents any enabled element. An element is enabled if it can be activated (selected, clicked on, typed into, etc.) or accept focus.
* `:first-child` - represents the first element among a group of sibling elements.
* `:first-of-type` - represents the first element of its type among a group of sibling elements.
* `:fullscreen` - matches every element which is currently in full-screen mode. If multiple elements have been put into fullscreen mode, this selects them all.
* `:focus` - represents an element (such as form input) that has received focus. It is generally triggered when the user clicks or taps on an element or selects it with the keyboard "tab" key.
  * Accessibility Concerns
    * Make sure your visual focus indicator can be seen by people with low vision.
    * `:focus { outline: 'none'}`
      * never just remove the focus outline (visible focus indicator) without replacing it with a focus outline that will pass.
      * removing outlines in CSS creates issues for people navigating the web with a keyboard
      * if you do not like the default focus outline that is displayed when a user clicks on an interactive element, you have 3 accessible solutions
        1. style the outline. consider the user of `a:focus { outline: thin-dotted }` to normalize the look of the outlines across browsers
        2. style the element itself. You can remove the outline as long as you style the focused element differently (using color, background-color, border, or text-decoration: outline; for example)
        3. remove outlines for mouse users only, if you truly *must* do so. *last resort solution*
* `:focus-within` - represents an element that has received focus or contains an element that has received focus. In other words, it represents an element that is itself matched by `:focus` pseudo-class or has a descendant that is matched by `:focus`. This includes descendants in shadow trees.
  * This selector is useful, to take a common example, for highlighting an entire `<form>` container when the user focuses on one of its `<input>` fields.
* `:hover` - matches when the user interacts with an element with a pointing device, but does not necessarily activate it. It is generally triggered when the user hovers over an element with the cursor (the pointer).
  * styles defined by the `:active` pseudo-class will be overridden by any subsequent link-related pseudo-class (:link :visited, or :active) that has at least equal specificity. To style links appropriately, put the `:hover` rule after the `:link` and `:visited` rules but before the `:active` one, as defined by the LVHA-order: `:link -- :visited -- :hover -- :active`.
  * **Note**: The `:hover` pseudo-class is problematic on touchscreens. Depending on the browser, the `:hover` pseudo-class might never match, match only for a moment after touching an element, or continue to match even after the user has stopped touching and until the user touches another element. Web developers should make sure that content is accessible on devices with limited or non-existent hovering capabilities.
* `:indeterminate` - represents any form element whose state is indeterminate.
  * elements targeted by this selector are:
    * `<input type="checkbox">` elements whose indeterminate property is to true by JS
    * `<input type="radio">` elements, when all radio buttons with the same name value in the form are unchecked
    * `<progress>` elements in an indeterminate state
* `:in-range` - represents an `<input>` element whose current value is within the range limits specified by the min and max attributes.
* `:invalid` - represents any `<input>` or other `<form>` element whose contents fail to validate. This pseudo-class is useful for highlighting field errors for the user.
  * accessibility concerns - the color red is commonly used to indicate invalid input. People who have certain types of color blindness will be unable to determine the input's state unless it is accompanied by an additional indicator that does not rely on color to convey meaning. Typically, descriptive text and/or an icon are used.
* `:lang()` - matches elements based on the language they are determined to be in. ex: `p:lang(en) > q {quotes: '<<' '>>'}`
* `:last-child` - represents the last element among a group of sibling elements
* `:last-of-type` - represents the last element of its type among a group of sibling elements
* `:link` - represents an element that has not yet been visited. It matches every unvisited `<a>, <area>, or <link>` element that has an href attribute.
  * styles defined by the `:active` pseudo-class will be overridden by any subsequent link-related pseudo-class (:link :visited, or :active) that has at least equal specificity. To style links appropriately, put the `:hover` rule after the `:link` and `:visited` rules but before the `:active` one, as defined by the LVHA-order: `:link -- :visited -- :hover -- :active`.
* `:not()` - represents elements that do not match a list of selectors. Since it prevents specific items from being selected , it is known as the *negation pseudo-class*.
  * Note: The ability to list more than one selector is experimental and not yet widely supported.
* `:nth-child()` - matches elements based on their position in a group of siblings
  * **syntax**: takes a single arg, which represents the pattern for matching the elements
    * *odd*
    * *even*
    * `An + B` - represents elements whose numeric position in a series of siblings matches this pattern, for every positive integer or zero value of n. The index of the first element is 1. The values of A and B must be both <integers>s.
* `:nth-last-child()` - matches elements based on their position among a group of siblings, counting from the end. Same syntax as `:nth-child()`
* `:nth-last-type()` - matches elements of a given type, based on their position among a group of siblings, counting from the end. Same syntax as `:nth-child()`
* `:nth-of-type()` - matches elements of a given type, based on their position among a group of siblings. Same syntax as `:nth-child()`
* `:only-child` - represents an element without any siblings
* `:only-of-type` - represents an element that has no siblings of the same type
* `:optional` - represents any `<input>,<select>, or <textarea>` element that does not have the `required` attribute set on it.
  * Accessibility Concerns
    * If a form contains optional `<input>`s, required inputs should be indicated using the required attribute. This will ensure that people navigating with the aid of assistive technology such as a screen reader will be able to understand which inputs need valid content to ensure a successful form submission.
* `:out-of-range` - represents an `<input>` element whose current value is outside the range limits specified by the min and max attributes.
* `:placeholder-shown` - represents any `<input> or <textarea>` element that is currently displaying placeholder text.
* `:read-only` - represents an element (such as a locked text input) that is not editable by the user. Need vendor prefix -moz-for firefox
* `:read-write` - represents an element (such as text input) that is editable by the user. This selector doesn't just select `<input>`s; it will select any element that can be edited by the user, such as a `<p>` element with `contenteditable` set on it.
* `:required` - represents any `<input>, <select> or <textarea>` element has the `required` attribute set on it.
  * If a form contains optional inputs, required inputs should be indicated visually using a treatment that does not rely solely on color to convey meaning. Typically, descriptive text and/or an icon are used.
* `:target` - represents a unique element (the target element) with an `id` matching the URL's fragment.
  * ex
  <pre>
  /* Selects an element with an ID matching the current URL's fragment */
  :target {
      border: 2px solid black;
  }
  </pre>
  * For example, the following url has a fragment (denoted by the #sign) that points to an element called `section2`
  http://www.example.com/index.html#section2
  * The following element would be selected by a `:target` selector when the current url is equal to the above.
  <pre><section id="section2">Example</section></pre>
  * You can also use the `:target` pseudo-class to create a lightbox without using any js. This technique relies on the ability to anchor links to point to elements that are initially hidden on the page. Once targeted, the CSS changes their `display` so that they are shown.
* `:valid` - represents any `<input> or other <form>` element whose contents validate successfully. This allows to easily make valid fields adopt an appearance that helps the user confirm that their data is formatted properly.
  * Accessibility Concerns
    * The color green is commonly used to indicate valid input. People who have certain types of color blindness will be unable to determine the input's state unless it is accompanied by an additional indicator that does not rely on color to convey meaning. Typically, descriptive text and/or an icon are used.
* `:visited` - represents links that the user has already visited. For privacy reasons, the styles that can be modified using this selector are very limited.

## CSS Pseudo-elements
* `::after` - creates a pseudo-element that is the last child of the selected element. It is often used to add cosmetic content to an element with the content property. It is inline by default.
  * ex: tooltips
* `::backdrop` - is a box the size of the viewport which is rendered immediately beneath any element being presented in full-screen mode. This includes both elements which have been placed in full screen mode using the FullScreen API and `<dialog>` elements. This pseudo element makes it possible to obscure, style, or completely hide everything located below the element when it's the topmost one in the top layer.
* `::before` - creates a pseudo-element that is the first child of the selected element. It is often used to add cosmetic content to an element with the `content` property. It is inline by default.
  * quotation marks
* `::first-letter` - applies styles to the first letter of the first line of a block-level element, but only when not preceded by other content (such as images or inline tables).
* `::first-line` - applies styles to the first line of a block level element. Note that the length of the first line depends on many factors, including the width of the element, the width of the document, and the font-size of the text.
* `::grammar-error` - represents a text segment which the user agent has flagged as grammatically incorrect.
  * *NOT SUPPORTED BY ANY BROWSER*
* `::placeholder` - represents the placeholder text of a form element
* `::selection` - applies styles to the part of a document that has been highlighted by the user (such as clicking and dragging the mouse across text).
* `::spelling-error` - represents a text segment which the user agent has flagged as incorrectly spelled.
  * *NOT SUPPORTED BY ANY BROWSER*

## CSS Font Styling

### `font-weight`
Sets the weight (boldness) of the font. The weights available depend on the font-family you are using.

#### Syntax
```css
/* Keyword values*/
font-weight: normal;
font-weight: bold;

/* Keyword values relative to the parent */
font-weight: lighter; /* one relative font weight lighter than the parent element.  */
font-weight: bolder; /* one relative font weight bolder than the parent element.  */
/*
Note when using relative weights, only 4 font weights are considered--thin(100), normal(400),
bold(700), and heavy(900).
*/

/* Numeric keyword values */
font-weight: 100;
font-weight: 200;
font-weight: 300;
font-weight: 400;// normal
font-weight: 500;
font-weight: 600;
font-weight: 700;// bold
font-weight: 800;
font-weight: 900;

/* Global values */
font-weight: inherit;
font-weight: initial;
font-weight: unset;
```
#### Common weight mapping
```text
100 	Thin (Hairline)
200 	Extra Light (Ultra Light)
300 	Light
400 	Normal (Regular)
500 	Medium
600 	Semi Bold (Demi Bold)
700 	Bold
800 	Extra Bold (Ultra Bold)
900 	Black (Heavy)
950 	Extra Black (Ultra Black)
```
#### Variable fonts
Most fonts have a particular weight which corresponds to one of the numbers in Common weight mapping. However, some fonts,
called variable fonts, can support a range of weights with a more or less fine granularity, and this can give the designer
a much closer degree of control over the chosen weight.

### `outline`
Is a shorthand to set various outline properties in a single declaration: `outline-style`, `outline-width`, and `outline-color`

#### Borders vs Outlines
Borders and outlines are very similar. However, outlines differ from borders in the following ways:
* Outlines never take up space, as they are drawn outside of an element's content.
* According to the spec, outlines don't have to rectangular, although they usually are.
#### Accessibility concerns
Assigning `outline` a value of `0` or `none` will remove the browser's default focus style. If an element can be
interacted with it must have a visible focus indicator. Provide obvious focus styling if the default focus style
is removed.

## CSS Styling Properties
### 'box-shadow'
Adds shadow effects around an element's frame. You can set multiple effects separated by commas. A box shadow is described
by X and Y offsets relative to the element, blur and spread radius, and color.

The `box-shadow` property enables you to cast a drop shadow from the frame of almost any element. If a `border-radius` is
specified on the element with a box shadow, the box shadow takes on the same rounded corners. The z-ordering of multiple
box shadows is the same as multiple text shadows (the first specified shadow is on top).

#### Syntax
```css
/* Keyword values */
box-shadow: none;

/* offset-x | offset-y | color */
box-shadow: 60px -16px teal;

/* offset-x | offset-y | blur-radius | color */
box-shadow: 10px 5px 5px black;

/* offset-x | offset-y | blur-radius | spread-radius | color */
box-shadow: 2px 2px 2px 1px rgba(0, 0, 0, 0.2);

/* inset | offset-x | offset-y | color */
box-shadow: inset 5em 1em gold;

/* Any number of shadows, separated by commas */
box-shadow: 3px 3px red, -1em 0 0.4em olive;

/* Global keywords */
box-shadow: inherit;
box-shadow: initial;
box-shadow: unset;
```
* `inset`- The presence of the `inset` keyword changes the shadow to one inside the frame (as if the content was depressed inside
  the box). Inset shadows are drawn inside the border (even transparent ones), above the background, but below content.
* `<offset-x> <offset-y>` - These are two length values to set the shadow offset. `<offset-x>` specifies the horizontal
  distance. Negative values place the shadow to the left of the element. `<offset-y>` specifies the vertical distance. Negative
  values place the shadow above the element. If both values are 0, the shadow is place behind the element (and may generate
  a blur effect if `<blur-radius>` and/or `<spread-radius>` is set).
* `<blur-radius>` - this is the 3rd length value. The larger this value, the bigger the blur, so the shadow becomes bigger
  and lighter. Negative values are not allowed. If not specified, it will be 0 (the shadow's edge is sharp).
* `<spread-radius>` - this is the 4th length value. Positive values will cause the shadow to expand and grow bigger, negative
  values will cause the shadow to shrink. If not specified, it will be 0 (the shadow will be the same size as the element).
* `<color>` - if not specified, it defaults to `currentcolor` (represents the value of an element's `color` property).

Using a semi-transparent color like `rgba(0, 0, 0, 0.4)` is most common, and a nice effect, as it doesn't completely/opaquely
cover what it's over, but allows what's underneath to show through a bit, like a real shadow.

#### One-side only
Using a negative spread radius, you can get squeeze in a box shadow and only push it off one edge of a box.

repository: jeffersonvivanco/WebProgrammingNotes

gha_language: HTML

repo_name: jeffersonvivanco/WebProgrammingNotes


text:
**@tatumio/tatum - v1.4.4**

> [README](../README.md) / [Globals](../globals.md) / ["src/model/request/TransferXlmOffchain"](../modules/_src_model_request_transferxlmoffchain_.md) / TransferXlmOffchain

# Class: TransferXlmOffchain

## Hierarchy

* [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md)

  ↳ **TransferXlmOffchain**

## Index

### Properties

* [address](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#address)
* [amount](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#amount)
* [attr](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#attr)
* [compliant](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#compliant)
* [fee](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#fee)
* [paymentId](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#paymentid)
* [secret](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#secret)
* [senderAccountId](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#senderaccountid)
* [senderNote](_src_model_request_transferxlmoffchain_.transferxlmoffchain.md#sendernote)

## Properties

### address

•  **address**: string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[address](_src_model_request_createwithdrawal_.createwithdrawal.md#address)*

*Defined in [src/model/request/CreateWithdrawal.ts:11](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L11)*

___

### amount

•  **amount**: string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[amount](_src_model_request_createwithdrawal_.createwithdrawal.md#amount)*

*Defined in [src/model/request/CreateWithdrawal.ts:17](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L17)*

___

### attr

• `Optional` **attr**: undefined \| string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[attr](_src_model_request_createwithdrawal_.createwithdrawal.md#attr)*

*Defined in [src/model/request/CreateWithdrawal.ts:39](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L39)*

___

### compliant

• `Optional` **compliant**: undefined \| false \| true

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[compliant](_src_model_request_createwithdrawal_.createwithdrawal.md#compliant)*

*Defined in [src/model/request/CreateWithdrawal.ts:26](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L26)*

___

### fee

• `Optional` **fee**: undefined \| string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[fee](_src_model_request_createwithdrawal_.createwithdrawal.md#fee)*

*Defined in [src/model/request/CreateWithdrawal.ts:22](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L22)*

___

### paymentId

• `Optional` **paymentId**: undefined \| string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[paymentId](_src_model_request_createwithdrawal_.createwithdrawal.md#paymentid)*

*Defined in [src/model/request/CreateWithdrawal.ts:30](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L30)*

___

### secret

•  **secret**: string

*Defined in [src/model/request/TransferXlmOffchain.ts:8](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/TransferXlmOffchain.ts#L8)*

___

### senderAccountId

•  **senderAccountId**: string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[senderAccountId](_src_model_request_createwithdrawal_.createwithdrawal.md#senderaccountid)*

*Defined in [src/model/request/CreateWithdrawal.ts:7](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L7)*

___

### senderNote

• `Optional` **senderNote**: undefined \| string

*Inherited from [CreateWithdrawal](_src_model_request_createwithdrawal_.createwithdrawal.md).[senderNote](_src_model_request_createwithdrawal_.createwithdrawal.md#sendernote)*

*Defined in [src/model/request/CreateWithdrawal.ts:34](https://github.com/tatumio/tatum-js/blob/c5d1e16/src/model/request/CreateWithdrawal.ts#L34)*

repository: kikaitech/tatum-js

repo_name: kikaitech/tatum-js


text:
# Contributing

When contributing to this repository, please first discuss the change
you wish to make via issue, email, or any other method with the owners
of this repository before making a change.

Please note we have a code of conduct, please follow it in all your
interactions with the project.

## Pull Request Process

Please create Pull Request(s) if you want to contribute. Make sure
that all tests go through and describe the proposed changes
accurately.

Project owners will check incoming PRs at least weekly. You may also
contact the project owner(s) to inform about the PR and start
discussing it.

## Code of Conduct

See CODE_OF_CONDUCT

repository: isecurefi/wscli-php

gha_language: PHP

repo_name: isecurefi/wscli-php


text:
- Keyboard `L/R` Rotate cone
- Mouse `L` Raycast in cone direction

https://github.com/armory3d/armory/wiki/physics#raycast

license: Zlib

gha_language: Haxe

gha_license_id: Zlib


text:
# Installation
> `npm install --save @types/babel__preset-env`

# Summary
This package contains type definitions for @babel/preset-env (https://github.com/babel/babel/tree/master/packages/babel-preset-env).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__preset-env.

### Additional Details
 * Last updated: Fri, 25 Sep 2020 23:55:30 GMT
 * Dependencies: none
 * Global values: none

# Credits
These definitions were written by [Slava Fomin II](https://github.com/slavafomin).

repository: wanglifa/webpack-loader-demo

repo_name: wanglifa/webpack-loader-demo


text:
# asset-manager-react
(In progress) Recreated a basic asset manager application using React

# Languages/Libraries/Frameworks used:

JavaScript, React, D3, Bootstrap, CSS

# User Flow

![Alt tag](http://g.recordit.co/ozPdAYmlln.gif)
User selects a risk profile - a number from 1 - 10.
User then inputs details regarding his/her current portfolio standings. This is a breakdown of 5 asset categories:

  1. Bonds
  2. Stocks
  3. ETFs
  4. Real Estate
  5. Cash

Based on these inputs, asset-manager will generate the following:

  1. A list of how assets should ideally be divided based on input risk profile.
  2. List of recommendations for how user can adjust current portfolio to ideal asset allocations (to mimic the doughnut chart)

# INSTALLATIONS

No installations necessary. All dependencies use links.


text:
---
layout: thingspost
title:  "Architecture"
date:   2017-06-20 09:00:00
isStaticPost: false
---
Iconic buildings in NYC:

* [The Flatiron Building](https://www.walksofnewyork.com/blog/flatiron-building-new-york)
* [The Chrysler Building](https://www.jamesmaherphotography.com/new-york-historical-articles/chrysler-building/)
* [432 Park Avenue](https://en.wikipedia.org/wiki/432_Park_Avenue) (you can buy a condo for $80M)
* [Via 57th West](https://www.via57west.com/#the-building-gallery)
* [Grand Central Terminal](http://www.grandcentralterminal.com/plan)
* Additional suggestions: [Best Architecture of NYC 2016](https://www.nytimes.com/2016/12/15/arts/comfort-and-joy-in-bricks-and-mortar.html?_r=0)

extension: markdown


text:
ElectionParty Chart
=================================================
 * By [Niklas Schoenberger](http://scn.sap.com/people/niklas.schoenberger)

This extension visualizes the relationship between defense spending and the party in charge for a given period in the US history. It includes an indicator line and a color indication for the political party

![ElectionParty Chart](https://github.com/SAP/lumira-extension-viz/blob/master/ElectionParty_Chart/ElectionParty_Chart.gif)

Download Extension
-----------
[ElectionParty Chart](https://github.com/SAP/lumira-extension-viz/blob/master/ElectionParty_Chart/sap.viz.ext.electionpartychart.zip?raw=true)

Files
-----------
* `ElectionParty_Chart_Sample.lums` - SAP Lumira file
* `ElectionParty_Chart_DataSample.csv` - Sample dataset
* `sap.viz.ext.electionpartychart.zip` - SAP Lumira extension, packaged with SAP WebIDE

Data Binding
-------------
Measures
* Expenditures

Dimensions
* Year
* Party
* President

Resources
-----------
* Blog post - Coming soon

repository: abgunes/lumira-extension-viz

repo_name: abgunes/lumira-extension-viz


text:
# aoc18
🎅 My Advent of Code 2018 solutions ❄

Running solvers

### `yarn solve`

Will solve both parts to the current days puzzle.
E.g. if today is December 5th, will attempt to solve both parts of `day5.js`.

### `yarn solve --day 1`

Solves both parts to Day 1

###`yarn *solve --day 3`

Solves both parts to Day 3

###`yarn solve --day 2 --part 1`

Solves just Part 1 of Day 2

###`yarn solve --day 4 --part 2`

Solves just Part 2 of Day 4


text:
## Advanced Lane Finding

In this project, a software pipeline was built to identify the lane boundaries in a video. Included in the repository is a detailed document explaining the steps followed in the project "Project2_Writeup.pdf".

The Project
---

The steps involved in the pipeline are as follows:

* Compute the camera calibration matrix and distortion coefficients using a set of chessboard images.
* Apply a distortion correction to raw images.
* Use color transforms, gradients, etc., to create a thresholded binary image.
* Apply a perspective transform to rectify binary image ("birds-eye view").
* Detect lane pixels and fit to find the lane boundary.
* Determine the curvature of the lane and vehicle position with respect to center.
* Warp the detected lane boundaries back onto the original image.
* Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.

The images for camera calibration are stored in the folder called `camera_cal`.  The images in `test_images` are for testing your pipeline on single frames.  If you want to extract more test images from the videos, you can simply use an image writing method like `cv2.imwrite()`, i.e., you can read the video in frame by frame as usual, and for frames you want to save for later you can write to an image file.

The resultant images generated by the pipeline are stored in `output_images`. The video called `project_video.mp4` was fed to the pipeline and its output is placed in the folder `output_vedios`.

repository: rohilnula/CarND-Advanced-Lane-Lines

repo_name: rohilnula/CarND-Advanced-Lane-Lines


text:
# Visiting Faculty at Avantika University, Ujjain.
Sample code and demo implemented during my lecture and hands on sessions at Avantika Universtiy, Ujjain.

Webservices using NodeJS and ExpressJS
- Task2 and Task3 to be completed by EOD today
- A 15 minutes discussion will be done tomorrow at the start

[Learning Session - Android App Development](https://docs.google.com/document/d/1AdCDFhRYe8r0I3EAuJ3L9zW20DRi4nLJIrTrnHAPqKE/edit#)

[Android Database debugging]
(https://github.com/amitshekhariitbhu/Android-Debug-Database)

[Genymotion Emulator]
(https://www.genymotion.com/)

repository: jaydeepw/avantika-university

repo_name: jaydeepw/avantika-university


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

### [2.0.4](https://github.com/plandek-utils/ts-time-utils/compare/v2.0.3...v2.0.4) (2021-02-05)

### [2.0.3](https://github.com/plandek-utils/ts-time-utils/compare/v2.0.2...v2.0.3) (2021-02-05)

### [2.0.2](https://github.com/plandek-utils/ts-time-utils/compare/v2.0.1...v2.0.2) (2021-02-05)

### [2.0.1](https://github.com/plandek-utils/ts-time-utils/compare/v2.0.0...v2.0.1) (2020-05-12)

### Bug Fixes

* target ES2017 instead of esnext for module, and ES2015 for main ([c6ccff2](https://github.com/plandek-utils/ts-time-utils/commit/c6ccff24aebf2dc5a3747f9ddbe12819572f2de7))
* **deps:** [security] bump acorn from 6.3.0 to 6.4.1 ([#66](https://github.com/plandek-utils/ts-time-utils/issues/66)) ([f5f8ec0](https://github.com/plandek-utils/ts-time-utils/commit/f5f8ec0f08dcab17189c9333067e70c0c623ea41))

## [2.0.0](https://github.com/plandek-utils/ts-time-utils/compare/v1.1.1...v2.0.0) (2020-04-15)

### ⚠ BREAKING CHANGES

* In v1.x dayjs objects were supported. This ended up being problematic because of
issues with dayjs versions. It also added a dependency that is not strictly needed. That's why from
v2.x on dayjs is no longer supported and it is removed as a dependency

### Features

* drop dayjs support + ensure unfreeze time if errors ([807e4b5](https://github.com/plandek-utils/ts-time-utils/commit/807e4b515580c8f2cd9e6799b4eff5bc32413500))

### [1.1.1](https://github.com/plandek-utils/ts-time-utils/compare/v1.1.0...v1.1.1) (2020-04-14)

### Bug Fixes

* **deps:** bump dayjs from 1.8.19 to 1.8.20 ([#51](https://github.com/plandek-utils/ts-time-utils/issues/51)) ([c50e5a5](https://github.com/plandek-utils/ts-time-utils/commit/c50e5a568074939f7f74b2622308f754e656d88d))
* **deps:** bump dayjs from 1.8.20 to 1.8.21 ([#58](https://github.com/plandek-utils/ts-time-utils/issues/58)) ([0d09391](https://github.com/plandek-utils/ts-time-utils/commit/0d09391cb7363a848c7f89e02a0fdd699c51fe00))

## [1.1.0](https://github.com/plandek-utils/ts-time-utils/compare/v1.0.0...v1.1.0) (2020-01-06)

### Features

* **deps:** update dayjs to latest ([8f7eb3c](https://github.com/plandek-utils/ts-time-utils/commit/8f7eb3cfc4974dd01f27b9ba96ea56b36288ae30))

### Bug Fixes

* **deps:** bump dayjs from 1.8.16 to 1.8.18 ([#21](https://github.com/plandek-utils/ts-time-utils/issues/21)) ([29e5bac](https://github.com/plandek-utils/ts-time-utils/commit/29e5baca0a1a3f5e658c689faca9534784346eb5))

## 1.0.0 (2019-11-05)

### Features

* initial implementation of `freezeTime` and `freezeTimeAwait` ([c4df449](https://github.com/plandek-utils/ts-time-utils/commit/c4df449c841b56faa392117b4d682efc99c20387))

repository: plandek-utils/ts-time-utils

repo_name: plandek-utils/ts-time-utils


text:
## GitHubPreview

[![GitHub license](https://img.shields.io/github/license/jbox-web/gh-preview.svg)](https://github.com/jbox-web/gh-preview/blob/master/LICENSE)
[![GitHub release](https://img.shields.io/github/release/jbox-web/gh-preview.svg)](https://github.com/jbox-web/gh-preview/releases/latest)
[![Gem](https://img.shields.io/gem/v/gh-preview.svg)](https://rubygems.org/gems/gh-preview/versions/1.0.0)
[![Gem](https://img.shields.io/gem/dtv/gh-preview.svg)](https://rubygems.org/gems/gh-preview/versions/1.0.0)
[![Build Status](https://travis-ci.org/jbox-web/gh-preview.svg?branch=master)](https://travis-ci.org/jbox-web/gh-preview)
[![Code Climate](https://codeclimate.com/github/jbox-web/gh-preview/badges/gpa.svg)](https://codeclimate.com/github/jbox-web/gh-preview)
[![Test Coverage](https://codeclimate.com/github/jbox-web/gh-preview/badges/coverage.svg)](https://codeclimate.com/github/jbox-web/gh-preview/coverage)

### A small Sinatra application to preview GitHub README files, easy ;)

This gem provides a small Sinatra application to preview GitHub README files or any markdown file.

**Notes** : The app can only serve one file at a time. If you need a more sophisticated rendering system, look at [Jekyll](https://github.com/jekyll/jekyll) ;)

## Installation

```ruby
gem install gh-preview
```

No need to add it to your Gemfile, it will be globally available.

## Usage

From any directory containing a ```README.md``` file :

```sh
nicolas@desktop:~/my/wonderful/application$ gh-preview server
```

Then open your browser at this url : [http://localhost:4000](http://localhost:4000).

## Options

```sh
Usage:
  gh-preview server [options]

Options:
  -f, [--file=FILE]  # File to serve   (default: README.md)
  -p, [--port=PORT]  # Port for server (default 4000)
```

## Contributors

A big thank to [them](https://github.com/jbox-web/gh-preview/blob/master/AUTHORS) for their contribution!

## Contribute

You can contribute to this plugin in many ways such as :

* Helping with documentation
* Contributing code (features or bugfixes)
* Reporting a bug
* Submitting translations

repository: jbox-web/gh-preview

repo_name: jbox-web/gh-preview


text:
# binance-alerts-telegram-bot
Telegram bot that alerts binance actions.

## Get it running

### Linux:
```bash
git clone https://github.com/danfmihai/bot-alerts.git
apt install build-essential python3.8 python3.8-dev
cd bot
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
nano .env                         # details below
python main.py
```

### .env file
```.env
BINANCE_API_KEY=
BINANCE_SECRET_KEY=
TELEGRAM_TOKEN=
MY_CHAT_ID=
```

1. Get your Binance API key and secret [here](https://accounts.binance.com/en/register).
2. Get your Telegram Token with [BotFather](https://t.me/BotFather).
3. Run the software without MY_CHAT_ID, start the conversation with the bot and paste the id shown in your shell.

## Commands

#### Cryptocurrency watchlist
Receive scheduled updates on the selected pair each n minutes.

Usage:
```
/watch <pair> <interval>       >> Adds to watchlist
    pair:       valid pair from Binance Exchange
    interval:   minutes between messages [min: 1  max: 1440 (day)]

/unwatch <pair>                >> Removes from watchlist
    pair:       pair on your watchlist

/watching                      >> Shows watchlist
```

#### Trade cryptocyrrency watchlist
Receive scheduled updates on the selected pair each n minutes.
To receive special alerts when abrupt changes occur, toggle ALERTING.

Usage:
```
/wtrade <pair> <interval> <enterPrice>      >> Adds to watchtrades-list
    pair:       valid pair from Binance Exchange
    interval:   minutes between messages [min: 1  max: 1440 (day)]
    enterPrice: base price to show actual position

/atrade <pair> <value>                      >> Change alerting value
    pair:       the pair to change the value
    value:      1 to activate, 0 to deactivate

/unwtrade <pair>                            >> Removes from watchtrades-list
    pair:       pair on your watchtrades-list

/wtrades                                    >> Shows watchtrades-list
```

### Telegram-like format command list
```
watch - add a cryptocurrency pair to your watchlist
unwatch - remove a pair from your watchlist
watching - show your watchlist
wtrade - add a trade to your watchtrades-list
atrade - set alerting for a specific watchtrade
unwtrade - remove a pair from your watchtrades-list
wtrades - show your watchtrades-list
```

repository: danfmihai/binance-alerts-telegram-bot

repo_name: danfmihai/binance-alerts-telegram-bot


text:
# How to Contribute to the OpenTelemetry Operator

We'd love your help!

This project is [Apache 2.0 licensed](LICENSE) and accepts contributions via GitHub pull requests. This document outlines some of the conventions on development workflow, contact points and other resources to make it easier to get your contribution accepted.

We gratefully welcome improvements to documentation as well as to code.

## Getting Started

### Workflow

It is recommended to follow the ["GitHub Workflow"](https://guides.github.com/introduction/flow/). When using [GitHub's CLI](https://github.com/cli/cli), here's how it typically looks like:

```
$ gh repo fork github.com/open-telemetry/opentelemetry-operator
$ git checkout -b your-feature-branch
# do your changes
$ git commit -sam "Add feature X"
$ gh pr create
```

### Pre-requisites
* Install [Go](https://golang.org/doc/install).
* Have a Kubernetes cluster ready for development. We recommend `minikube` or `kind`.

### Local run

Build the manifests, install the CRD and run the operator as a local process:
```
$ make manifests install run
```

### Deployment with webhooks

When running `make run`, the webhooks aren't effective as it starts the manager in the local machine instead of in-cluster. To test the webhooks, you'll need to:

1. configure a proxy between the Kubernetes API server and your host, so that it can contact the webhook in your local machine
1. create the TLS certificates and place them, by default, on `/tmp/k8s-webhook-server/serving-certs/tls.crt`. The Kubernetes API server has also to be configured to trust the CA used to generate those certs.

In general, it's just easier to deploy the manager in a Kubernetes cluster instead. For that, you'll need the `cert-manager` installed. You can install it by running:

```console
make cert-manager
```

Once it's ready, the following can be used to build and deploy a manager, along with the required webhook configuration:

```
make manifests docker-build docker-push deploy
```

By default, it will generate an image following the format `quay.io/${USER}/opentelemetry-operator:${VERSION}`. You can set the following env vars in front of the `make` command to override parts or the entirety of the image:

* `IMG_PREFIX`, to override the registry, namespace and image name (`quay.io`)
* `USER`, to override the namespace
* `IMG_REPO`, to override the repository (`opentelemetry-operator`)
* `VERSION`, to override only the version part
* `IMG`, to override the entire image specification

Your operator will be available in the `opentelemetry-operator-system` namespace.

## Testing

With an existing cluster (such as `minikube`), run:
```
USE_EXISTING_CLUSTER=true make test
```

Tests can also be run without an existing cluster. For that, install [`kubebuilder`](https://book.kubebuilder.io/quick-start.html#installation). In this case, the tests will bootstrap `etcd` and `kubernetes-api-server` for the tests. Run against an existing cluster whenever possible, though.

## Project Structure

For a general overview of the directories from this operator and what to expect in each one of them, please check out the [official GoDoc](https://godoc.org/github.com/open-telemetry/opentelemetry-operator) or the [locally-hosted GoDoc](http://localhost:6060/pkg/github.com/open-telemetry/opentelemetry-operator/)

## Contributing

Your contribution is welcome! For it to be accepted, we have a few standards that must be followed.

### New features

Before starting the development of a new feature, please create an issue and discuss it with the project maintainers. Features should come with documentation and enough tests (unit and/or end-to-end).

### Bug fixes

Every bug fix should be accompanied with a unit test, so that we can prevent regressions.

### Documentation, typos, ...

They are mostly welcome!

repository: maneeshs/opentelemetry-operator

repo_name: maneeshs/opentelemetry-operator


text:
---
title: "Adding Styles and Scripts"
weight: 22
draft: true
menu:
  main:
    parent: creating-component
    weight: 22
---

To add CSS to a component, you can add a style file either as a plain CSS file (.css), or as a [Stylus](http://stylus-lang.com/) file (.styl). In this tutorial, we will use Stylus.

Create `style.styl` in your `BlockQuote` folder, so that your theme folder matches the following:

```
├── flynt-starter-theme
|  ├──Components
|  |  ├── BlockQuote
|  |  |  ├── fields.json
|  |  |  ├── index.twig
|  |  |  └── style.styl
```

Next, lets open `style.styl` and add some basic styling. We'll be using the [recommended Flynt best practices](/guide/best-practices/styles/) when it comes to styling our component.

```stylus
.flyntComponent[is='flynt-block-quote']
  *,
  *:before,
  *:after
    box-sizing: border-box

  .blockQuote
    background: #ccc
    padding: 30px
    border-left: 5px solid #558c89
```

Providing you have run `flynt start` in your terminal (from the flynt theme directory), Flynt will now compile `Components/BlockQuote/style.styl` into `dist/Components/BlockQuote/style.css`.

## Enqueuing your assets
There is **one crucial step** missing. To load these styles into the front end, you must enqueue these styles using the `functions.php` file of your component. The [functions file](/documentation/components/server-side-logic/) can be used for all of your custom server side logic that is specific to your component.

First, create `functions.php` inside your BlockQuote component. Your theme folder should now look like this:

```
├── flynt-starter-theme
|  ├──Components
|  |  ├── BlockQuote
|  |  |  ├── fields.json
|  |  |  ├── functions.php
|  |  |  ├── index.twig
|  |  |  └── style.styl
```

Inside `functions.php` we will use the [Components feature](/guide/features/what-is-feature/) inside the [WordPress `wp_enqueue_scripts` action](https://codex.wordpress.org/Plugin_API/Action_Reference/wp_enqueue_scripts) to enqueue our style file. This 'action' is one of [many hooks provided by WordPress](https://codex.wordpress.org/Plugin_API#Hooks:_Actions_and_Filters) to allow us to 'hook into' the rest of WordPress at a specific time. Flynt comes with a range of features that take advantage of these hooks, which [you can explore here](/guide/features/what-is-feature).

Add the following code to `Components/BlockQuote/functions.php`.

```php
<?php
namespace Flynt\Components\BlockQuote;

use Flynt\Features\Components\Component;

add_action('wp_enqueue_scripts', function () {
    Component::enqueueAssets('BlockQuote');
});
```

Flynt will now look for `Components/BlockQuote/style.css`, and enqueue the file if it is found.

Refresh the front end of your website and you will now see your styles!

## Adding scripts
To add custom JavaScript logic to your component, create a `script.js` file inside your component, so that your theme folder matches the following:

```
├── flynt-starter-theme
|  ├──Components
|  |  ├── BlockQuote
|  |  |  ├── fields.json
|  |  |  ├── functions.php
|  |  |  ├── index.twig
|  |  |  ├── script.js
|  |  |  └── style.styl
```

Inside `script.js` you can add all of the JavaScript logic that you need. Flynt supports [ES2015 (ES6)](https://babeljs.io/learn-es2015/) out of the box, and will compile your script to ES5 using [Babel](https://babeljs.io/). ES2015 is a significant update to the JavaScript language, but it is only [our recommendation](/tutorials/best-practices/scripts/). You do not have to use this and can write your JavaScript inside `script.js` however you wish.

Open `Components/BlockQuote/script.js` and add the following:

```js
class BlockQuote extends window.HTMLDivElement {
  connectedCallback () {
    console.log('The BlockQuote component has been inserted into the DOM!')
  }
}

window.customElements.define('flynt-block-quote', BlockQuote, {extends: 'div'})
```

To load this script into the front end, you must ensure you have enqueued the assets for this component, [as shown above](/tutorials/creating-component/adding-styles-scripts/#enqueuing-your-assets). Flynt will then look for `Components/BlockQuote/script.js` and enqueue the file if it is found.

That's it - refresh the front end and check your console! You have now completed your first component.

Tutorial Complete!

Congratulations on creating your first component with a view template, dynamic fields, styles, and scripts.

Next Steps

Explore the full Component documentation.

Learn about our recommended Flynt best practices.

Leave feedback regarding this tutorial or the documentation on Github.

gha_language: CSS


text:
📦 Binaries
----
Binaries for linux, mac and windows are included in this github release

🐳 Docker
----
| Name                 | Description                                                                                |
| -------------------- | ------------------------------------------------------------------------------------------------------------ |
| `lindell/revaboxy:$DOCKER_VERSION`        | Minimal image, made from the [scratch](https://hub.docker.com/_/scratch) image. Probably everything you need |
| `lindell/revaboxy:$DOCKER_VERSION-alpine` | Image based on [alpine](https://hub.docker.com/_/alpine). If you need a shell and package manager            |

Docker images are found at dockerhub [lindell/revaboxy](https://hub.docker.com/r/lindell/revaboxy)

📡 Release Notes
----
* Example

repository: iCodeIN/revaboxy-proxy

repo_name: iCodeIN/revaboxy-proxy


text:
# serverless-django-zeit-now
A simple template for deploying a headless Django installation as a serverless function a.k.a. lambda on Zeit Now 2.0.

For more information, please see this blog post: https://reinikainen.net/blog/serverless-django-zeit-now/

repository: reinikai/serverless-django-zeit-now

gha_language: Python

repo_name: reinikai/serverless-django-zeit-now


text:
Digital Audio Restoration
-------------------------

Click and pop removal using an autoregressive model (AR) and sinusoid + AR model.

A paper outlining the implementation is available here: http://www.music.mcgill.ca/~greg/courses/MUMT605/MUMT605finalpaper.pdf

An implementation of algorithms from the book: S. J. Godsill and P. J. W. Rayner, Digital Audio Restoration - A Statistical Model-Based Approach. London, UK: Springer-Verlag, September 1998.

repository: gburlet/audio-restore

repo_name: gburlet/audio-restore


text:
# Google App Engine Pagination

Demo https://ndbpagination.appspot.com/offset_pagination

Here are some code samples of how to implement pagination with GAE and NDB

First create items in datastore:
[http://localhost:8080/create]

or with offset
[http://localhost:8080/offset_pagination](http://localhost:8080/offset_pagination)

Feel free to use it, modify, leave comments, improve :)


text:
# Ticker

### Description
The 'Ticker' component is a type of news ticker. It scrolls text from right to left. It can run continuously on a loop, or just once. If text is changed while it is running, the current text finishes displaying before the new text starts.
To utilize this tool,
 - The text field should be the text to display, or the text can be set using the setText function.
 - The text can be appended to using the addText function.
 - The default position of the image is in the lower right corner of the video, with a 10px margin on the right and bottom.

### Usage
| Field | Type | Default | Options | Required | AccessPermission | Description |
| ----------- | ----------- | ----------- | ----------- | ----------- | ----------- | ----------- |
| logoUri | uri | | | true | READ_WRITE | The uri of the image. |
| text | string | "" | | true | READ_WRITE | The text to scroll. |
| scrollSpeed | float | 100 | | false | READ_WRITE | The speed of the scrolling in pixels per second. |
| width | float | 1920 | | false | READ_WRITE | The width of the Ticker component. |
| color | color | | | false | READ_WRITE | The text color. |
| font | node | | | false | READ_WRITE | The text's font. |
| vertAlign | string | | | false | READ_WRITE | The text's vertAlign field. |

repository: avoltis/rocute

repo_name: avoltis/rocute


text:
1. Clone this repo https://github.com/kpozdnikin/react-redux-saga-test-app
2. Move to the appropriate directory: `cd react-redux-saga-test-app`.

3. Run `npm install` to install dependencies.

4. Run `npm start` to see the example app at `http://localhost:3000`.

Have a nice day!

K.Pozdnikin

repository: kpozdnikin/react-redux-saga-test-app

repo_name: kpozdnikin/react-redux-saga-test-app