text:
## JavaScript

# Item 1: Know Which JavaScript You Are Using
* Decide which versions of JavaScript your application supports.
* Be sure that any JavaScript features you use are supported by all environments where your application runs.
* Always test strict code in environments that perform the strict-mode checks.
* Beware of concatenating scripts that differ in their expectations about strict mode.

#7 False Values in JavaScript
* ""
* False
* 0
* -0
* NAN
* null
* undefined

# Item 2: Understand JavaScript Floating-Point Numbers
* All numbers in JavaScript are double-precision floating-point numbers, 64-bit encoding of numbers, also known as "doubles".
* Bitwise operators implicitly converts integers  to 32-bit signed integers.
* Integers in JavaScript are just a subset of doubles rather than a
separate datatype.
* Be aware of limitations of precisions in floating-point arithmetic.

# Item 3: Beware of Implicit Coercions
* Type errors can be silently hidden by implicit coercions.
* The '+' operator is overloaded to do addition or string concatenation depending on its argument types.
* Objects are coerced to numbers via 'valueOf' and to strings via 'toString'.
* Objects with 'valueOf' methods should implement a 'toString' method that provides a string representation of the number produced by 'valueOf'.
* Use 'typeOf' or comparison to 'undefined' rather than truthiness to test for undefined values.

# The 5 JavaScript Primitives Values
* Booleans
* Numbers
* Strings
* Null
* Undefined
* Symbols (ECMAScript 6)

# Item 4: Prefer Primitives to Object Wrappers
* Object wrappers for primitive types do not have the same behavior as their primitive values when compared for equality.
* Getting and setting properties on primitives implicitly creates object wrappers.

# Item 5: Avoid using '==' with Mixed Types
* The '==' operator applies a confusing set of implicit coercion when its arguments are of different types.
* Use '===' to make it clear to your readers that your comparisons does not involve any implicit coercions.
* Use your own explicit coercions when comparing values of different types to make your program's behavior clearer.

# Item 6: Learn the Limits of Semicolon Insertion
* Semicolons are only ever inferred before a '}' at the end of a line, or at the end of a program.
* Semicolons are only ever inferred when the next token cannot be parsed.
* Never omit a semicolon before a statement beginning with '(','[','+','-',or '/'.
* When concatenating scripts, insert semicolons explicitly between scripts.
* Never put a newline before the argument to 'return', 'throw', 'break', 'continue', '++', or '--'.
Semicolons are never inferred as separators in the head of a 'for' loop or as empty statements.

# Item 7: Think of Strings As Sequences of 16-Bit Code Units
* An element of a JavaScript string is a 16-bit code units, not Unicode code points.
* Unicode points 2^16 and above are represented in JavaScript by two code units, known as a surrogate pair.

* Use third-party libraries for writing code point-aware string manipulation.
* Whenever you are using a library that works with strings, consult the documentation to see how it handles the full range of code points.

# Item 8: Minimize Use of the Global Object
* Avoid declaring global variables.
* Declare variables as locally as possible.
* Avoid adding properties to the global object.
* Use the global object for platform feature detection.

# Item 9: Always Declare Local Variables
* Always declare new local variables with var.

# Item 10: Avoid 'with'
* Avoid using with statements.
* Use short variable names for repeated access to an object.
* Explicitly bind local variables to object properties instead of implicitly binding them with a 'with' statement.

# Item 11: Get Comfortable with Closures
* Functions can refer to variables defined in outer scopes.
* Closures can outlive the function that creates them.
* Closures internally store references to their outer variables, and can both read and update their stored variables.

# Item 12: Understand Variable Hoisting
* Variable declarations within a block are implicitly hoisted to the top of their enclosing function.
* Redeclarations of a variable are treated as a single variable.
* Consider manually hoisting local variable declarations to avoid confusion.

# Item 13: Use Immediately Invoked Function Expressions to Create Local Scopes
* Understand the difference between binding and assignment.
* Closures capture their outer variables by references, not by value.
* Use immediately invokes function expressions (IIFEs) to create local scopes.
* Be away of the cases where wrapping a block in an IIFE can change its behavior.

# Item 14: Beware of Unportable Scoping of Named Function Expressions
* Use names function expressions to improve stack traces in 'Error' objects and debuggers.
* Beware of pollution of function expression scope with 'Object.prototype' in ES3 and buggy JavaScript environments.
* Beware of hoisting and duplicate allocation of named function expressions in buggy JavaScript environments.
* Consider avoiding named function expressions or removing them before shipping.
* If you are shipping in properly implemented ES5 environments, you've got nothing to worry about.

# Item 15: Beware of Unportable Scoping of Block-local Function Declarations
* Always keep function declarations at the outermost level of a program or a containing function to avoid unportable behavior.
* Use var declarations with conditional assignment instead of conditional function declarations.

# Item 16: Avoid Creating Local Variables with eval
* Avoid creating variables with eval that pollute the caller's scope.
* If eval code might create global variables, wrap the call in a nested function to prevent scope pollution.

Item 17: Prefer Indirect eval to Direct eval
* Wrap eval in a sequence expression with a useless literal to force the use of indirect eval.
* Prefer indirect eval to direct eval whenever possible.

## Chapter 3

# Item 18: Understand the Difference between Function, Method, and Constructor Calls
* Method calls provide the object in which the method property is looked up as their receiver.
* Function calls provide the global object(or undefined for strict functions) as their receiver. Calling methods with function call syntax is rarely useful.
* Constructors are called with new and receive a fresh object as their receiver.

Item 19: Get Comfortable Using Higher-Order Functions
* Higher-order functions are functions that take other functions as arguments or return functions as their result.
* Familiarize yourself with higher-order functions in existing libraries.
* Learn to detect common coding patterns that can be replaced by higher-order functions.

Item 20: Use call to Call Methods with a Custom Receiver
* Use the call method to call a function with a custom receiver.
* Use the call method for calling methods that may not exist on a given object.
* Use the call method for defining higher-order functions that allow clients to provide a receiver for the callback.

Item 21: Use apply to Call Functions with Different Numbers of Arguments
* Use the apply method to call variadic functions with a computed array of arguments.
* Use the first argument of apply to provide a receiver for variadic methods.

# Item 22: Use arguments to Create Variadic Functions
* Use the implicit arguments object to implement variable-arity functions.
* Consider providing additional fixed-arity versions of the variadic functions you provide so that your consumers don't need to use the apply method.

# Item 23: Never Modify the arguments Object
* Never modify the arguments object.
* Copy the arguments object to a real array using [].slice.call(arguments) before modifying it.

# Item 24: Use a Variable to Save a Reference to arguments
* Be aware of the function nesting level when referring to arguments.
* Bind an explicitly scoped reference to arguments in order to refer to it from nested functions.

# Item 25: Use bind to Extract Methods with a Fixed Receiver
* Beware that extracting a method does not bind the method's receiver to its object.
* When passing an object's method to a higher-order function, use an anonymous function to call the method on the appropriate receiver.
* Use bind as a shorthand for creating a function bound to the appropriate receiver.

# Item 26: Use bind to Curry Functions
* Use bind to curry a function, that is, to create a delegating function with a fixed subset of the required arguments.
* Pass null or undefined as the receiver argument to curry a function that ignores its receiver.

# Item 27: Prefer Closures to Strings for Encapsulating Code
* Never include local references in strings when sending them to APIs that execute them with eval.
* Prefer APIs that accept functions to call rather than strings to eval.

# Item 28: Avoid Relying on the toString Method of Functions
* JavaScript engines are not required to produce accurate reflections of function source code via toString
* Never rely on precise details of function source, since different engines may produce different results from toString
* The results of toString do not expose the values of local variables stored in a closure.
* In general, avoid using toString on functions.

# Item 29: Avoid Non Standard Stack Inspection Properties:
* Avoid the nonstandard arguments.call and arguments.callee, because they are not reliably portable.
* Avoid the nonstandard caller property of functions, because it does not reliably contain complete information about the stack.

## Chapter 4
# Item 30: Understand the Difference between prototype, getPrototypeOf, and __proto__
* C.prototype determines the prototype of objects created by new C()
* Object.getPrototypeOf(obj) is the standard ES5 function for retrieving the prototype of an object.
* obj.__proto__ is a nonstandard mechanism for retrieving the prototype of an object.
* A class is a design pattern consisting of a constructor function and an associated prototype.

Item 31: Prefer Object.getPrototypeOf to __proto__
* Prefer the standards-compliant Object.getPrototypeOf standart __proto__ property.
* Implement Object.getPrototypeOf in non-ES5 environments tha support __proto__.

# Item 32: Never Modify __proto__
* Never modify an object's __proto__ property.
* Use Object.create to provide a custom prototype for new objects.

# Item 33: Make Your Constructors new-Agnostic
* Make a constructor agnostic to its caller's syntax by reinvoking itself with new or with Object.create.
*Document clearly when a function expects to be called with new.

# Item 34: Store Methods on Prototypes
* Storing methods of instance objects creates multiple copies of functions, once per instance object.
* Prefer storing methods on prototypes over storing them on instance objects.

# Item 35: User Closures to Store Private Data
* Closure variables are private, accessible only to local references.
* Use local variables as private data to enforce information hiding within methods.

# Item 36: Store Instance State Only on Instance Objects
* Mutable data can be problematic when shared, and prototypes are shared between all their instances.
* Store mutable per-instance state on instance objects.

# Item 37: Recognize the Implicit Binding of this
* The scope of this is always determined by its nearest enclosed function.
* Use a local variable, usually called self, me, or that, to make a this-binding available to inner functions.

# Item 38: Call Superclass Constructors from Subclass Constructors
* Call the superclass constructor explicitly from subclass constructors, passing this as the explicit receiver.
* Use Object.create to construct the subclass prototype object to avoid calling the superclass constructor.

# Item 49: Never Reuse Superclass Property Names
* Be aware of all property names used by your superclasses.
* Never reuse a superclass property name in a subclass.

# Item 40: Avoid Inheriting from Standard Classes
* Inheriting from standard classes tens to break due to special internal properties such as [[Class]].
* Prefer delegating to properties instead of inheriting from standard classes.

# Item 41: Treat Prototypes As an Implementation Detail
* Objects are interfaces; prototypes are implementations.
* Avoid inspecting the prototype structure of objects you don't control.
* Avoid inspecting properties that implement the internals of objects you don't control.

# Item 42: Avoid Reckless Monkey-Patching
* Avoid reckless monkey-patching.
* Document any monkey-patching performed by a library.
* Consider making monkey-patching optional by performing the modifications in an exported function.
* Use monkey-patching to provide pollyfills for missing standard APIs.

<!-- Chapter 5 -->

# Item 43: Build Lightweight Dictionaries from Direct Instances of Object
* Use object literals to construct lightweight dictionaries.
* Lightweight dictionaries should be direct descendants of Object.prototype to protect against prototype pollution in for..in loops.

#Item 44: Use null Prototypes to Prevent Prototype Pollution
* In ES5, use Object.create(null) to create prototype-free empty objects that are less susceptible to pollution.
* In older environments, consider using {__proto__: null}.
* But beware that __proto__ is neither standard more entirely portable and may be removed in future JavaScript environments.

# Item 45: Use hasOwnProperty to Protect Against Prototype Pollution
* Use hasOwnProperty to protect against prototype pollution.
* Use lexical scope and call to protect against overriding of the hasOwnProperty method.
* Consider implementing dictionary operations in a class that encapsulates the boilerplate hasOwnProperty tests.
* Use a dictionary class to protect against the use of "__proto__" as a key.

# Item 46: Prefer Arrays to Dictionaries for Ordered Collections
* Avoid relying on the order in which for...in loops enumerate object properties.
* If you aggregate data in a dictionary, make sure the aggregate operations are order-insensitive.
* Use arrays instead of dictionary objects for ordered collections.

# Item 47: Never Add Enumerable Properties to Object.prototype
* Avoid adding properties to Object.prototype.
* Consider writing a function instead of an Object.prototype method.
* If you do add properties to Object.prototype, use ES5's Object.defineProperty to define them as nonenumerable properties.

# Item 48: Avoid Modifying an Object During Enumeration
* Make sure not to modify an object while enumerating its properties with a for...in loop.
* Use of while loop or classic for loop instead of a for...in loop when iterating over an object whose contents might change during the loop.
* For predictable enumeration over a changing data structure, consider using a sequential data structure such as an array instead of a dictionary object.

# Item 49: Prefer for Loops to for...in Loops for Array Iteration
* Always use a for loop rather than a for...in loop for iterating over the indexed properties of an array.
* Consider storing the length property of an array in a local variable before a loop to avoid recomputing the property lookup.

# Item 50: Prefer Iteration Methods to Loops
* Use iteration methods such as Array.prototype.forEach and Array.prototype.map in place of for loops to make code more readable and avoid duplicating loop control logic.
* Use custom iteration functions to abstract common loop patterns that are not provided by the standard library.
* Traditional loops can still be appropriate in cases where early exit is necessary; alternatively, the some and every methods can be used for early exit.

# Item 51: Reuse Generic Array Methods on Array-Like Objects
* Reuse generic Array methods on array-like objects by extracting method objects and using their call method.
* Any object can be used with generic Array methods if it has indexed properties and an appropriate length property.

# Item 52: Prefer Array Literals to the Array Constructor
* The Array constructor behaves differently if its first argument is a number.
* Use array literals instead of the Array constructor.

# Item 53: Maintain Consistent Conventions
* Use consistent conventions for variable names and function signatures.
* Don't deviate from conventions your users are likely to encounter in other parts of their development platform.

$ Item 54: Treat undefined As "No Value"
* Avoid using undefined to represent anything other than the absence of a specific value.
* Use descriptive string values or objects with named boolean properties, rather than undefined or null, to represent application-specific flags.
* Test for undefined instead of checking arguments.length to provide parameter default values.

# Item 55: Accept Options Objects for Keyword Arguments
* Use options objects to make APIs more readable and memorable.
* The arguments proved by an options object should all be treated as optional.
* Use an extend utility function to abstract out the logic of extracting values from options objects.

# Item 56: Avoid Unnecessary State
* Prefer stateless APIs where possible.
* When providing stateful APIs, document the relevant state that each operation depends on.

# Item 57: Use Structural Typing for Flexible Interfaces
* Use structural typing(also known as duck typing) for flexible object interfaces.
* Avoid inheritance when structural interfaces are more flexible and lightweight.
* Use mock objects, that is, alternative implementations of interfaces that provide repeatable behavior, for unit testing.

# Item 58: Distinguish between Array and Array-Like
* Never overload structural types with other overlapping types.
* When overloading a structural type with other types, test for other types first.
* Accept true arrays instead of array-like objects when overloading with other object types.
* Document whether your API accepts true arrays or array-like values.
* Use ES5's Array.isArray to test for true arrays.

# Item 59: Avoid Excessive Coercion
* Avoid mixing coercions with overloading.
* Consider defensively guarding against unexpected inputs.

# Item 60: Support Method Chaining
* Use method chaining to combine stateless operations.
Support method chaining by designing stateless methods that produce new objects.
* Support method chaining in stateful methods by returning this.

<!-- Chapter 7 -->
# Item 61: Don't Block the Event Queue on I/O
* Asynchronous APIs take callbacks to defer processing of expensive operations and avoid blocking the main application.
* JavaScript accepts events concurrently but processes event handlers sequentially using an event queue.
* Never use blocking I/O in an application's event queue.

# Item 62: Use Nested or Named Callbacks for Asynchronous Sequencing
* Use nested or named callbacks to perform several asynchronous operations in sequence.
* Try to strike a balance between excessive nesting of callbacks and awkward naming of non-nested callbacks.
* Avoid sequencing operations that can be performed concurrently.

* Item 63: Be Aware of Dropped Errors
* Avoid copying and pasting error-handling code by writing shared error-handling functions.
* Make sure to handle all error conditions explicitly to avoid dropped errors.

# Item 64: Use Recursion for Asynchronous Loops
* Loops cannot be asynchronous.
* Use recursive functions to perform iterations in separate turns of the event loop.
* Recursion performed in separate turns of the event loop does not overflow the call stack.

# Item 65: Don't Block the Event Queue on Computation
* Avoid expensive algorithms in the main event queue.
* On platforms that support it, the Worker API can be used for running long computations in a separate event queue.
* When the Worker API is not available or is too costly, consider breaking up computations across multiple turns of the event loop.

# Item 66: Use a Counter to Perform Concurrent Operations
* Events in a JavaScript application occur nondeterministically, that is, in unpredictable order.
* Use a counter to avoid data races in concurrent operations.

# Item 67: Never Call Asynchronous Callbacks Synchronously
* Never call an asynchronous callback synchronously, even if the data is immediately available.
* Calling an asynchronous callback synchronously disrupts the expected sequence of operations and can lead to unexpected interleaving of code.
* Calling an asynchronous callback synchronously can lead to stack overflows or mishandled exceptions.
* Use an asynchronous API such as setTimeout to schedule an asynchronous callback to run in another turn.

# Item 68: Use Promises for Cleaner Synchronous Logic
* Promises represent eventual values. that is, concurrent computations that eventually produce a result.
* Use promises to compose different concurrent operations.
* Use promise APIs to avoid data races.
* Use select (also known as choose) for situations where an intentional race condition is required.


text:
# deno-context

![.github/workflows/test.yml](https://github.com/Code-Hex/deno-context/workflows/.github/workflows/test.yml/badge.svg)

🦕【Deno】Propagate deadlines, a cancellation and other request-scoped values to multiple promise. The behaviour is like Go's context.

## Synopsis

This example passes a context with a timeout to tell a blocking methods that it should abandon its work after the timeout elapses.

```typescript
import * as context from "./context.ts";

const tooSlow = (
  ctx: context.Context,
  ms: number,
): Promise<number> => {
  return new Promise<number>((resolve, reject) => {
    const id = setTimeout((): void => {
      clearTimeout(id);
      resolve();
    }, ms);
    ctx.done()?.onCanceled((reason?: any) => {
      clearTimeout(id);
      reject(reason);
    });
    return ms;
  });
};

const ctx = new context.Background();
const tctx = new context.WithTimeout(ctx, 1000); // timeout by 1000ms

try {
  await Promise.race([
    tooSlow(tctx, 3000), // take 3s
    tooSlow(tctx, 4000), // take 4s
    tooSlow(tctx, 5000), // take 5s
  ]);
} catch (e) {
  // Get this error by 1000ms.
  // DeadlineExceeded: context deadline exceeded
  console.warn(e);
} finally {
  tctx.cancel(); // To prevent leak.
}
```

## About Context

Most of the descriptions in here are copied and edited from the following links.
https://golang.org/pkg/context

This library defines the Context type, which carries deadlines,
cancellation signals, and other request-scoped values across API boundaries.

The WithCancel and WithTimeout functions take a
Context (the parent) and return a derived Context (the child) and a cancel method.
Calling the cancel method cancels the child and its children, removes the parent's
reference to the child, and stops any associated timers. Failing to call the cancel
method leaks the child and its children until the parent is canceled or the timer
fires.

Programs that use Contexts should follow these rules to keep interfaces consistent across
libraries. Do not store Contexts inside any classes; instead, pass a Context explicitly to
each function and method that needs it. The Context should be the first parameter,
typically named ctx:

```typescript
  function DoSomething(ctx: context.Context, arg Arg): context.ContextPromise<void> {
    return new context.ContextPromise(ctx, (resolve, reject) => {
      // ... use ctx ...
    }
  }

  ... or

  function DoSomething(ctx: context.Context, arg Arg): Promise<void> {
    return new Promise((resolve, reject) => {
      // ... use ctx ...
    }
  }
```

## context.Background

```typescript
const ctx = new context.Background();
```

Background returns a non-nil, empty Context. It is never canceled, has
no values, and has no deadline. It is typically used by the main function,
initialization, and tests.

## context.WithValue

```typescript
const ctx = new context.Background();
const vctx = new context.WithValue(ctx, "key", "value");
```

WithValue returns a copy of parent in which the value associated with key is val.

Use context Values only for request-scoped data that transits processes and APIs,
not for passing optional parameters to functions.

 Example

```typescript
const ctx = new context.Background();

const key = "language";
const vctx = new context.WithValue(ctx, key, "Deno");

const f = (ctx: context.Context, key: string): void => {
  const v = ctx.value(key);
  if (v != undefined) {
    console.log("found value:", v);
    return;
  }
  console.log("key not found:", key);
};

f(vctx, key);
f(vctx, "color");
```

## context.WithCancel

```typescript
const ctx = new context.Background();
const cctx = new context.WithCancel(ctx);
```

WithCancel returns a copy of parent with a new done signal.

The returned context's done signal is signaled when the cancel method is called or
when the parent context's done signal is signaled, whichever happens first.

 Example

```typescript
const ctx = new context.Background();
const cctx = new context.WithCancel(ctx);

const canceler = async () => {
  await tooSlow(cctx, 1000);
  cctx.cancel();
}

// Run asynchronously
canceler();

try {
  await Promise.race([
    tooSlow(cctx, 3000),
    tooSlow(cctx, 4000),
    tooSlow(cctx, 5000),
  ]);
} catch (e) {
  // Canceled: context canceled
  console.warn(e);
} finally {
  cctx.cancel(); // To prevent leak.
}
```

### Callback to be performed on cancel

The specified callback will be executed only once in the event that is emitted when the cancel method is called.

If the cancel method has already been called, the passed callback will be executed immediately.

 Example

```typescript
import * as context from "./context.ts";

const ctx = new context.Background();
const cctx = new context.WithCancel(ctx);

cctx.done().onCanceled((reason?: any) => {
  console.log("canceled reason:", reason)
})

console.log("start cancel")
cctx.cancel();
console.log("canceled")
```

## context.WithTimeout

```typescript
const ctx = new context.Background();
const tctx = new context.WithTimeout(ctx, 1000);
```

WithTimeout returns a copy of the parent context with the timeout
adjusted to be no later than “ms". If the parent's timeout is already
earlier than “ms", WithTimeout(parent, ms) is semantically equivalent
to parent.

The returned context's done signal is signaled when the timeout expires,
when the returned cancel method is called, or when the parent context's
done signal is signaled, whichever happens first.

license: MIT

repository: Code-Hex/deno-context

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: Code-Hex/deno-context


text:
# Order Manager RESTful Service

In this exercise, you will build an Order management service which follows the RESTful service principles.

The objectives are:

- Design a RESTful service with that encapsulate four resources for order management
operations what includes create, read, update and delete.

- Create Order : To place a new order, use an HTTP POST request that contains order details, and then send the request to the http://localhost:9090/order endpoint.
If the request is successful, the service should respond with a 201 Created HTTP response that has the location header pointing to the newly created resource at http://localhost:9090/order/123456.
- Retrieve Order : To retrieve order details, send an HTTP GET request to the appropriate URL that includes the order ID.http://localhost:9090/order/.
- Update Order : To update an existing order, send an HTTP PUT request with content for the order update.
- Delete Order : To delete an existing order, send an HTTP DELETE request to the http://localhost:9090/order/ endpoint.
- All incoming and outgoing order request are sent in JSON format with the following structure:
    Sample order req : `` { "Order": { "ID": "100500", "Name": "my order", "Description": "my order desc"}} ``
- Order are stored in an in-memory map which is defined at the service level.
- You can assume that following request and response messages are sent by the service.

1. Create Order

HTTP POST on `` http://localhost:9090/ordermgt/order ``with the following payload :

``'{ "Order": { "ID": "100500", "Name": "XYZ", "Description": "Sample order."}}'  ``

Expected response: HTTP 201 with Location header and order status.

```
< HTTP/1.1 201 Created
< Content-Type: application/json
< Location: http://localhost:9090/ordermgt/order/100500
< content-length: 46
< server: ballerina/0.981.0
{"status":"Order Created.","orderId":"100500"}
```

2. Retrieve Order

HTTP GET request on : `` http://localhost:9090/ordermgt/order/100500 ``

Output :
`` {"Order":{"ID":"100500","Name":"XYZ","Description":"Sample order."}}``

3. Update Order on http://localhost:9090/ordermgt/order/100500

`` { "Order": {"Name": "XYZ", "Description": "Updated order."}}``

Output :
```
{"Order":{"ID":"100500","Name":"XYZ","Description":"Updated order."}}
```

4. Cancel Order

HTTP Delete on `` http://localhost:9090/ordermgt/order/100500``

Output:
`` "Order : 100500 removed." ``

#Running the tests

If you haven't initialized the environment, please execute the following command.
```sh
[~/Exercism/ballerina]$ ballerina init
```
You can run all the tests for an exercise by entering
```sh
[~/Exercism/ballerina]$ ballerina test service-invocation
```
in your terminal.

## Submitting Incomplete Solutions
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

repository: cmccandless/ballerina

gha_license_id: MIT

repo_name: cmccandless/ballerina


text:
# Software Team Generator
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  ## Table of Contents
  - [Description](https://github.com/brennandoehring/softwareteamgenerator#description)
  - [Installation](https://github.com/brennandoehring/softwareteamgenerator#installation)
  - [Usage](https://github.com/brennandoehring/softwareteamgenerator#usage)
  - [License](https://github.com/brennandoehring/softwareteamgenerator#license)
  - [Contributors](https://github.com/brennandoehring/softwareteamgenerator#contributors)
  - [Questions](https://github.com/brennandoehring/softwareteamgenerator#questions)

  ## Description
  A simple command line application that prompts the user for information about the team manager as well as the team members. Once team info has been input, an HTML file will be generated that displays the team roster based on the information given.

  ## Installation
  Clone the repo. Open folder in VSC. Run "npm i inquirer" in console. Run "node app.js". Input as needed.

  ## Usage
  This project is good for displaying information of your development team. It allows easy access for the team itself and employers to find emails and other info about the employees.

  ## License
  This project is licensed under MIT.

  ## Contributors
  I was the only contributor to this project.

  ## Questions
  If you have any questions please contact me at<EMAIL_ADDRESS>My github profile username is bddoehring.

  ## Screenshots/Videos/GIFs
  Screenshot of output
  Link to YouTube demonstration: https://www.youtube.com/watch?v=OVTWyzbeDOs

repository: brennandoehring/softwareteamgenerator

branch_name: refs/heads/main

repo_name: brennandoehring/softwareteamgenerator


text:
huck
====

> 'Cause just like in the classic mis-adventure, Tom doesn't really
> pull his weight.  So Huck is gathering all the toml parsers and
> making them betterer.

A library for making toml betterer.

Usage
-------------
Usage docs to follow.

Compatibility
-------------

This is intended to be a [v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
compatible parser.

TODO
-------------
 * inline table support
 * pretty printing of Toml documents
 * roundtrip tests on pretty printer
 * include BurntSushi suite of toml documents
 * whitespace preserving
 * Fixup top level import and haddocks (top level haddock documentation needs explicit exports)

STATUS
-------------

Unfinished, unmaintained and likely superseeded by [tomland](https://github.com/kowainik/tomland).
Most everything I wanted to do with this library has been done in `tomland` either better or sooner that I could have.

repository: tmcgilchrist/huck

gha_language: Haskell

repo_name: tmcgilchrist/huck


text:
# Shadow-Lines-Filling-of-Closed-Polygon
```
  Course project, Computer Graphics
  College of Electrical & Information Engineering, Tongji University
  Chengyuan Deng
  Date: Nov. 2016
```

### I. Description & Design
  The target of this project is implementing an algorithm to fill an arbitrary polygon with shadow lines. Shadow lines are regarded as a set of paralelled slashes with identical interspace, the amount of interspace and slope can be customized.
   #### Functions:
  (I) Arbitrary polygon with any number or position of edges and vertices
  (II) Customized interspace and slope
  (III) Fill the polygon with shadow lines
### II. Development Environment
  Visual Studio 2017
  OpenGL
### III. Instructions
Execute ShadowFill.cpp, the console will appear and ask for number of edges of the polygon.

After the number is specified, console canvas will show up for drawing out the polygon by clicking on each vertex.

Meanwhile, the coordinates of each vertex will be shown on the console.

Last, input gradient of shadow lines and distance between adjacent lines

Click the right button of mouse to refresh
#### Show of results:


text:
---
title: Performance
---

<!-- markdownlint-disable MD033 -->

One of the main reasons for building Konviw is performance. A medium complex page in Confluence may take between 6 an 7s to load completely. Of course this is because Confluence is loading all the heavy assets to edit pages, create new content, search, navigate thru the complete page hierarchy of the space... But who wants to wait for 7s when you just want to read the content.

This is an example of the Lighthouse performance report on the [demo Styles](demoStyles) page.

![Confluence Lighthouse report](https://konviw.vercel.app/cpv/wiki/download/attachments/35225651/image-20210502-140806.png?version=1&modificationDate=1619964489513&cacheVersion=1&api=v2)

Running the Lighthouse performance on the same page rendered by konviw…
Wow, this is much better!

And of course this is for a page with many images and assets we can’t touch and improve with konviw. If we run Lighthouse in a page with fewer images, yep, even better. And those tests are run disabling the cache of the browser and the NestJS cache (with parameter cache=no-cache).

![konviw Lighthouse report](https://konviw.vercel.app/cpv/wiki/download/attachments/35225651/image-20210502-141206.png?version=1&modificationDate=1619964728448&cacheVersion=1&api=v2)

Our objective with konviw is to deliver pages in average below 1 second. Obviously while Atlassian API delivers the content in the current levels of performance so around 500 ms per page.

We will continue to add features but always looking to keep the current levels of performance and speed to deliver beautifully rendered pages. We will not compromise the performance for new features in any case.

repository: PiiXiieeS/konviw

repo_name: PiiXiieeS/konviw


text:
# Date and Time Format

We recommend using the [ISO 8601 standard](https://www.gov.uk/government/publications/open-standards-for-government/date-times-and-time-stamps-standard) to represent date and time in the API payload response. This helps people read the time correctly and consistently across WOG.

Use a consistent date format. For dates, this looks like 2018-09-09. For dates and times, use the form **2018-09-09T13:58:07Z.**

repository: robincher/gds-api-guides

repo_name: robincher/gds-api-guides


text:
# Capro Site

This is a static [Capro](https://github.com/xy2z/capro) site! This file is auto generated, feel free to edit this as you please.

## Build

Run `vendor/bin/capro build` to build your site. Or if you have capro installed globally, you can just run `capro build`.


text:
# CLEAR:Composition of Likelihoods for Evolve And Resequence Experiments

##Overview
CLEAR is a tool for identifying selection in time-series pooled-sequencing data. A bioRxiv preprint is available [here](http://biorxiv.org/content/early/2016/10/13/080085).

##Requirements
CLEAR is written in python which uses `seaborn`, `numba` and `pandas` packages.You can install required packages by running

`conda install pandas numba seaborn`

##Running
To obtain  CLEAR simply execute

`git clone --recursive https://github.com/airanmehr/CLEAR.git`

repository: airanmehr/CLEAR

repo_name: airanmehr/CLEAR


text:
# MQTT STANDARD HELPER LIBRARY
**Node-js Mqtt helper utility**

Node Js utility for dealing with common mqtt related tasks.
Like extracting values from a nested payload structure.

## Release 1.0.0
Initial release of code and configuration examples.
Tested on linux.

## How to Install
Clone or unzip repository.
Open shell or the windows cmd, cd inside and type:
```js
npm install
```

## How to run
Simply reference in a different application:
const stdMqtt = require("../stdMqtt/stdMqtt");

stdMqtt.getPayloadChunk(pathPieces, jsonTopicPayload)

## Testing the logger
The basic logging functionality can be tested by running:
1) npm run test
2) node stdMqttTests.js

repository: bakterian/stdMqtt

repo_name: bakterian/stdMqtt


text:
# AWS Golden AMI Pipeline with Qualys (Supports both Windows and Linux/Unix EC2 instances)

Allows for current and future AWS and Qualys customers to implement the AWS Golden AMI Pipeline reference architecture utilizing the Qualys Scanner Appliance to scan for and report on the vulnerabilities and configuration compliance on golden image builds in the image creation process.
It uses the AWS Cloud Formation Template to assess Vulnerabilities in the EC2 instance (Windows & Linux/Unix) using Qualys scanner appliance and embeds Qualys Cloud Agent into the golden AMI. EC2 instances can be then, provisioned from these Golden AMIs and will get scanned by Qualys Cloud Agent continuously.

 TO THE EXTENT PERMITTED BY LAW, QUALYS HEREBY DISCLAIMS ALL WARRANTIES AND LIABILITY FOR THE PROVISION OR USE OF THIS SCRIPT. IN NO EVENT SHALL THESE SCRIPTS BE DEEMED TO BE CLOUD SERVICES AS PROVIDED BY QUALYS***

## Description
You can use this Cloudformation template for AWS Golden AMi Pipleine with Qualys, supports (Windows and Linux/Unix).

## Pre-Requisites:
1. All the pre-requisites mentioned in the existing PDF document should remain unchanged.

## Assumptions:
All Assumptions mentioned in the existing PDF should remain unchanged.

## Scan Workflow Pre-requisites:
Qualys Scan Flow Prerequisites
1. Create Qualys EC2 Connector
2. Create a AWS Key pair for authenticated scans on linux/Windows.
3. Define Qualys Vulnerability Scan Option Profile
4. Deploy Virtual Scanner in VPC or into a peered VPC
5. Define parent tag ID
6. Define a Policy Compliance Option Profile

## Steps:
### A] Before creating cloud formation stack using the AWS golden AMI pipeline template, ensure you note down the following information, either on clipboard, notepad or any other text editor tool.

1. EC2 Connector Id: This is connector Id of EC2 connector available in Qualys Asset View. EC2 connector creation can be done using the EC2 connector creation CF or script.
2. EC2 Connector Name: Name of the EC2 connector in Qualys Asset view.
3. VM Option Id: Id of the option profile that will be used for scanning Ec2 instance.
4. SSH Key Pair name: the AWS key pair name created for authenticating EC2 instances.
5. Parent Tag Id: Tag Id of Qualys Asset tag created in Asset view.
6. Scanner name: A general name for Qualys Scanner Appliance. For this, you need to create a Scanner Appliance in Qualys and note down its Personalization code.
7. Agent Location for DebianRPM/Windows installers: The s3 url where Qualys cloud agent installers are uploaded.
8. Activation ID & Customer Id: The agent Activation Id and customer Id retrieved from Qualys Portal.

### B] Deploy the Cloud formation template:
1. Login to AWS Console, then navigate to CloudFormation. click 'Create stack' > With new resources (standard).
2. Within Specify template, select 'Upload a template file'. Upload teh AWS Golden AMI pipeline Cloud fornation template file provided by Qualys on github. Once, file is uploaded, click 'Next'.
3. Provide the input values for parameters as in Step A. Click Next.
4. on Last page, check 'I acknowledge that AWS CloudFormation might create IAm resources' check box and click 'Create stack' to initiate deployment process.

gha_license_id: NOASSERTION


text:
`#sass` `#css` `#html` `#master-in-software-engineering`

# SASS - Clone Instagram

> Sass (which stands for 'Syntactically awesome style sheets) is an extension of CSS that enables you to use things like variables, nested rules, inline imports and more
>
> The purpose of this project is to learn the basics of SASS and put them into practice by building a visual replica of Instagram

## Index

- [Requirements](#requirements)
- [Repository](#repository)
- [Technologies used](#technologies-used)
- [Project delivery](#project-delivery)
- [Resources](#resources)
- [Questions](#questions)

## Requirements

- You must use variables at least once in the project.
- You must use nesting.
- You must use inheritance at least once in the project.
- You cannot use third party libraries for the development of this pill

## Repository

First of all you must fork this project into your GitHub account.

To create a fork on GitHub is as easy as clicking the “fork” button on the repository page.

### Installing

In this project you must use the VSCode SASS extension in order to compile SASS into CSS.

First of all you will need to install the extension:

- [Live SASS Compiler](https://marketplace.visualstudio.com/items?itemName=ritwickdey.live-sass)

When the extension is installed correctly, having a SASS file open, you must click on "Watch Sass":

If you want to change some configuration of "Live SASS Compiler" you can check this official resource:

- [Live SASS Compiler Settings](https://github.com/ritwickdey/vscode-live-sass-compiler/blob/master/docs/settings.md)

## Technologies used

\* SASS

\* CSS

\* HTML

## Project delivery

To deliver this project you must follow the steps indicated in the document:

- [Submitting a solution](https://www.notion.so/Submitting-a-solution-524dab1a71dd4b96903f26385e24cdb6)

## Resources

- [SASS documentation](https://sass-lang.com/)
- [W3S SASS](https://www.w3schools.com/sass/)
- [SASS Guidelines](https://sass-guidelin.es/es/)
- [Organizing SASS Projects](https://blog.prototypr.io/how-i-organize-sass-projects-e2d7760df86f)
- [Why don't use @import](https://www.youtube.com/watch?v=CR-a8upNjJ0)

## Questions

•	What is SASS? What does SASS stand for?
SASS (which stands for ‘Syntactically awesome style sheets’) is an  areo f b of CSS that enables you to use things like variables, nested rules, inline imports and more. It also helps to keep things organised and allows you to  areo  style sheets faster.

•	What is a CSS pre-processor?

The pre-processor is  areo f ble for transpiling scss files into browser-readable css code.

•	What does a pre-processor have to do with SASS?

The preprocessor takes  areo f translating scss to css

•	Why use SASS?

Stylesheets are getting larger, more complex, and harder to maintain. This is where a CSS pre-processor can help.

Sass lets you use features that do not exist in CSS, like variables, nested rules, mixins, imports, inheritance, built-in functions, and other stuff.

•	SASS has disadvantages? Which are?

o	The developer must have enough time to learn new features present in this preprocessor before using it.
o	Using Sass may cause losing benefits of browser’s built-in element inspector.
o	Code has to be compiled
o	 Difficult  Troubleshooting

•	What is a SASS Variable? Explain why are useful

Think of variables as a way to store information that you want to reuse throughout your stylesheet.
You can store things like colors, font stacks, or any CSS value you think you'll want to reuse. Sass uses the $ symbol to make something a variable.
•	Explain the SASS variables property with an example.

•	What is a mixin? Why is it important? Give an example

A mixin lets you make groups of CSS declarations that you want to reuse throughout your site.
To create a mixin you use the @mixin directive and give it a name. We've named our mixin transform. We're also using the variable $property inside the parentheses so we can pass in a transform of whatever we want. After you create your mixin, you can then use it as a CSS declaration starting with @include followed by the name of the mixin.

•	What is SCSS? Give an example

SCSS (Sassy CSS): Uses the .scss file extension and is fully compliant with CSS syntax. It is the new version of SASS.

•	What is SASS? Give an example
Indented (simply called 'Sass'): Uses .sass file extension and indentation rather than brackets; it is not fully compliant with CSS syntax, but it's quicker to write. It’s the old version of SASS, but it will never be deprecated!

•	What is the difference between .scss and .sass syntax.

.sass file extension use indentation and .scss use brackets

•	In which cases would we use SCSS? And in which cases would we use SASS?

•	Explain how traditional CSS and Preprocessed CSS workflows are different.

The preprocessor will translate .scss to .css and the traditional scss will read css files from top to bottom.

•	Can we create functions with SASS? If it is true, give an example.

•	What is nesting? Is it useful? Give an example of nesting

When writing HTML you've probably noticed that it has a clear nested and visual hierarchy. CSS, on the other hand, doesn't.
Sass will let you nest your CSS selectors in a way that follows the same visual hierarchy of your HTML. Be aware that overly nested rules will result in over-qualified CSS that could prove hard to maintain and is generally considered bad practice.

•	Difference between @use & @import? Give an example

The @import directive allows you to include the content of one file in another. (deprecated)

The new @use is similar to @import. but has some notable differences:
-	The file is only imported once, no matter how many times you @use it in a project.

-	Variables, mixins, and functions (what Sass calls “members”) that start with an underscore (_) or hyphen (-) are considered private, and not imported.

-	Members from the used file are only made available locally, but not passed along to future imports.
-	All imported members are namespaced by default.

•	How can we import other CSS/SASS files in SASS? Give an example

•	Explain the concept of inheritance in SASS.

If you want share a set of CSS properties from one selector to another.
•	Why use @extend? Give an example

Using @extend lets you share a set of CSS properties from one selector to another.
A placeholder class is a special type of class that only prints when it is extended, and can help keep your compiled CSS neat and clean.

repository: badyalberto/sass-clone-instagram

repo_name: badyalberto/sass-clone-instagram


text:
Build Status Server
-------------------

![Preview image in action](preview.png "Server running with some data")

Templates allow flexible display of data in HTML5 tables.
Backend REST code is accessible through rest_api.py.

repository: hbirchtree/coffeecutie-build-daemon

repo_name: hbirchtree/coffeecutie-build-daemon


text:
## Input Files for Pipeline Tests

### Raw Evidence

The data in evidence_raw.json contains an extract with real data as well as some simulated data to force corner cases (simulated-records.json).

The real data extracted was done by notebooks/testing/evidence-test-data-extractor.ipynb.

The simulated examples have the following changes:
- line 1 - Target validation - sim001-badtargetid
    - target.id is changed to http://identifiers.org/ensembl/ENSG999999 which will clear schema checks but not match
- line 2 - Disease validation - sim002-badefoid
    disease.id changed to http://www.ebi.ac.uk/efo/BAD_EFO_ID (which will also pass schema validation and not match)
- line 3 - Biotype filtering - sim003-excludedbiotype
    - source changed to expression_atlas and gene id changed to ENSG00000240253 as this will have a biotype to be excluded
- line 4 - Biotype filtering - sim004-includedbiotype
    - source changed to expression_atlas and gene id changed to PCSK9 (ENSG00000169174) so it will NOT
    have a biotype exclusion
- line 5 - Source validation - sim005-badsource
    - clone of line 1 with source changed to "bad_source_id" (must be lower case to pass schema validation)
- line 6 - ECO score enforcement - sim006-ecoscore-rsdiff
    - valid genetic_association record with gene2variant.resource_score added having type "probability" and
    value .0001 not matching that for the value associated with the gene2variant.functional_consequence
    ECO code (SO_0001060 -> .5) in static value mapping (see https://storage.googleapis.com/open-targets-data-releases/19.11/input/annotation-files/eco_scores-2019-10-31.tsv)
- line 7 - ECO score enforcement - sim007-ecoscore-rsnull
    - same as 6 with gene2variant.resource_score removed
- line 8 - ECO score enforcement - sim008-ecoscore-rsequal
    - Same as 6 with gene2variant.resource_score set to equal value, i.e. .5
- line 9 - ECO score enforcement - sim009-ecoscore-badecoid
    - Same as 6 with value changed to .3 and ECO code at gene2variant.functional_consequence changed
    to SO_0000000 to test that unmapped ECO codes result in no override
- line 10 - ECO code aggregation - sim010-ecocodeagg
    - Same as 6 with nothing changed, as it already as gene2variant and variant2disease evidence_codes
    to be asserted against expectation (should result in codes 'ECO_0000205' and 'PheWAS')

In each of the above, a field is added at target.target_name (as it is not constrained by the json schema)

repository: related-sciences/platform-pipe

gha_language: Jupyter Notebook

repo_name: related-sciences/platform-pipe


text:
# Diplodia oleae Peglion, 1894 SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Malpighia 8: 22 [of sepr. ] (1894)

#### Original name
Diplodia oleae Peglion, 1894

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
## What is this for?

If you are writing a C# program that consumes MusicXML files (a digital format for sheet music), it may be helpful to deserialize MusicXML files to a strongly typed class instead of manually parsing the XML document.

These C# classes help you do that. They are auto-generated from the official MusicXML schema definition files using the [XmlSchemaClassGenerator](https://github.com/mganss/XmlSchemaClassGenerator) project.

## Excerpt Sample

```cs
 ...
 ...
 ...

 /// <summary>
    /// <para>The score-partwise element is the root element for a partwise MusicXML score. It includes a score-header group followed by a series of parts with measures inside. The document-attributes attribute group includes the version attribute.</para>
    /// </summary>
    [System.CodeDom.Compiler.GeneratedCodeAttribute("XmlSchemaClassGenerator", "<IP_ADDRESS>")]
    [System.SerializableAttribute()]
    [System.Xml.Serialization.XmlTypeAttribute("score-partwise", Namespace="", AnonymousType=true)]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlRootAttribute("score-partwise", Namespace="")]
    public partial class ScorePartwise
    {

        [System.Xml.Serialization.XmlElementAttribute("work", Namespace="")]
        public Work Work { get; set; }

        /// <summary>
        /// <para>The movement-number element specifies the number of a movement.</para>
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute("movement-number", Namespace="")]
        public string MovementNumber { get; set; }

        /// <summary>
        /// <para>The movement-title element specifies the title of a movement, not including its number.</para>
        /// </summary>
        [System.Xml.Serialization.XmlElementAttribute("movement-title", Namespace="")]
        public string MovementTitle { get; set; }
 ...
 ...
 ...
 28,500 more lines...
```

## Usage Example

I briefly tested each C# class against one MusicXML file sourced from MuseScore.org (ClassicMan's transcription of Chopin's Scherzo No. 2 Op. 31):

```cs
using System;
using System.Xml.Serialization;
using System.IO;

namespace ExampleProgram
{
    static class Program
    {
        static void Main()
        {
            XmlSerializer serializer = new XmlSerializer(typeof(MusicXmlSchema.ScorePartwise));

            // Uncompress the MusicXML file if it ends with a .mxl before passing it in
            string filename = "scherzo-no-2-opus-31.xml";

            // Your fully typed score
            var score = serializer.Deserialize(new FileStream(filename, FileMode.Open)) as MusicXmlSchema.ScorePartwise;

            Console.WriteLine(score.Credit[0].CreditWords.Value);
            // Output: Scherzo No. 2 in B♭ Minor
            Console.WriteLine(score.Part[0].Measure[0].Note[0].Pitch.Step);
            // Output: B

            Console.ReadKey();
        }
    }
}

```

## Folder Structure

Each folder contains:

- The original MusicXML schema definition files as downloaded from [musicxml.com](
https://www.musicxml.com/for-developers/musicxml-xsd/) for that version
- The converted XSD -> C# class for XML deserialization

## Generation

1. [Run XmlSchemaClassGenerator](https://github.com/sightreader/XmlSchemaClassGenerator/commit/957617e0a6602f774f9c68e3796c50f2eb4da62e#diff-962ecf59898691a00089b77166a0114aR26) on each MusicXML version of the `musicxml.xsd` files.
2. Manually remove some extra generated classes `X_1`, `X_2` (there were 19 instances of these extra classes).

## Credits

Thanks to [XmlSchemaClassGenerator](https://github.com/mganss/XmlSchemaClassGenerator) for a great conversion library.

I tried other tools like .NET's built-in `xsd.exe` and the commercial `xsd2code`, but both `xsd.exe` and `xsd2code` do not pascal case names (they capitalizes the first letter but doesn't pascal case according to the dashes in element names).

The original `XmlSchemaClassGenerator` uses `_` underscores between words instead of plain pascal casing so [this fork](https://github.com/sightreader/XmlSchemaClassGenerator) has a quick patch to remove the `_` to allow plain pascal casing.

The generated C# classes also contained some repeat _1 _2 _3 suffix classes that caused errors when I tried the usage example so I manually removed those.

repository: sightreader/musicxml-schemas

gha_language: C#

repo_name: sightreader/musicxml-schemas


text:
[![GeoSolutions](https://www.geo-solutions.it/wp-content/uploads/2014/12/logo_geo-solutions.jpg)](https://www.geo-solutions.it/)

This is a [GeoSolutions](https://www.geo-solutions.it/) project. By contributing you agree to abide by the [Contributor Code of Conduct](https://www.geo-solutions.it/about/conduct) and follow the [guidelines](https://www.geo-solutions.it/about/guidelines).

# Contribute to Django MapStore2 Adapter

Thanks for your interest, we love contributions!

 1. [Getting Involved](#getting-involved)
 2. [Reporting Bugs](#reporting-bugs)
 3. [Contributing Code](#contributing-code)
 4. [Improving Documentation](#improving-documentation)

## Getting Involved

There are several ways you can contribute to MapStore 2 development.
If you are a developer, you can contribute new features and bug fixes, using pull requests.
But you can also help by discovering and [reporting bugs](#reporting-bugs);
[improving documentation](#improving-documentation);
helping others on the [MapStore users mailing list](https://groups.google.com/d/forum/mapstore-users)
and [GitHub issues](https://github.com/geosolutions-it/MapStore2/issues).

## Reporting Bugs

Before reporting a bug on the project's [issues page](https://github.com/geosolutions-it/MapStore2/issues),
first make sure that your issue is caused by MapStore 2, not your application code
(e.g. passing incorrect arguments to methods, etc.).
Second, search the already reported issues for similar cases,
and if it's already reported, just add any additional details in the comments.

After you've made sure that you've found a new MapStore 2 bug,
here are some tips for creating a helpful report that will make fixing it much easier and quicker:

 * Write a **descriptive, specific title**. Bad: *Map does not show*. Good: *Doing X in IE9 causes Z*.
 * Include **browser, OS and MapStore 2 version** info in the description.
 * Create a **simple test case** that demonstrates the bug (e.g. using [JSFiddle](http://jsfiddle.net/) or [JS Bin](http://jsbin.com/)).
 * Check whether the bug can be reproduced in **other browsers**.
 * Check if the bug occurs in the stable version, master, or both.
 * *Bonus tip:* if the bug only appears in the master version but the stable version is fine,
   use `git bisect` to find the exact commit that introduced the bug.

If you just want some help with your project,
try asking [on the MapStore users mailing list](https://groups.google.com/d/forum/mapstore-users) instead.

## Contributing Code

### Considerations for Accepting Patches

While we happily accept patches, we're also committed to quality.
So bugfixes, performance optimizations and small improvements that don't add a lot of code
are much more likely to get accepted quickly.

Before sending a pull request with a new feature, check if it's been discussed before already
(either on [GitHub issues](https://github.com/geosolutions-it/MapStore2/issues)
or [on the MapStore developers mailing list](https://groups.google.com/d/forum/mapstore-developers)),
and ask yourself two questions:

 1. Are you sure that this new feature is important enough to justify its presence in the MapStore 2 core?
    Or will it look better as a plugin in a separate repository?
 2. Is it written in a simple, concise way that doesn't add bulk to the codebase?

If your feature did get merged into master,
please consider submitting another pull request with the corresponding [documentation update](#improving-documentation).

### Making Changes to MapStore 2 Source

If you're not yet familiar with the way GitHub works (forking, pull requests, etc.),
be sure to check out the awesome [article about forking](https://help.github.com/articles/fork-a-repo)
on the GitHub Help website — it will get you started quickly.

You should always write each batch of changes (feature, bugfix, etc.) in **its own topic branch**.
Please do not commit to the `master` branch, or your unrelated changes will go into the same pull request.

### Pull request guidelines

Your pull request must:

 * Follow MapStore 2's coding style.

 * Pass the integration tests run automatically by the Travis Continuous
   Integration system.

 * Address a single issue or add a single item of functionality. (Start the pull request title with the addressed issues if in case)

 * Contain a clean history of small, incremental, logically separate commits,
   with no merge commits.

 * Use clear commit messages.

 * Be possible to merge automatically.

### Pass the integration tests run automatically by the Travis CI system

The integration tests contain a number of automated checks to ensure that the
code follows the MapStore 2 style and does not break tests or examples.  You
can run the integration tests locally using the `test` target.

### Address a single issue or add a single item of functionality

Please submit separate pull requests for separate issues.  This allows each to
be reviewed on its own merits.

### Contain a clean history of small, incremental, logically separate commits, with no merge commits

The commit history explains to the reviewer the series of modifications to the
code that you have made and breaks the overall contribution into a series of
easily-understandable chunks.  Any individual commit should not add more than
one new class or one new function.  Do not submit commits that change thousands
of lines or that contain more than one distinct logical change.  Trivial
commits, e.g. to fix lint errors, should be merged into the commit that
introduced the error.  See the [Atomic Commit Convention on Wikipedia](http://en.wikipedia.org/wiki/Atomic_commit#Atomic_Commit_Convention) for more detail.

`git apply --patch` and `git rebase` can help you create a clean commit
history.
[Reviewboard.org](http://www.reviewboard.org/docs/codebase/dev/git/clean-commits/)
and [Pro GIT](http://git-scm.com/book/en/Git-Tools-Rewriting-History) have
explain how to use them.

### Use clear commit messages

Commit messages should be short, begin with a verb in the imperative, and
contain no trailing punctuation. We follow
http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
for the formatting of commit messages.

Git commit message should look like:

    Header line: explaining the commit in one line

    Body of commit message is a few lines of text, explaining things
    in more detail, possibly giving some background about the issue
    being fixed, etc etc.

    The body of the commit message can be several paragraphs, and
    please do proper word-wrap and keep columns shorter than about
    74 characters or so. That way "git log" will show things
    nicely even when it's indented.

    Further paragraphs come after blank lines.

Please keep the header line short, no more than 50 characters.

### Be possible to merge automatically

Occasionally other changes to `master` might mean that your pull request cannot
be merged automatically.  In this case you may need to rebase your branch on a
more recent `master`, resolve any conflicts, and `git push --force` to update
your branch so that it can be merged automatically.

## Improving Documentation

TBD

## Thank You

At the end, however you decide to contribute to the project, your help is very
welcome and we would like to thank you for doing it.

repository: geosolutions-it/django-mapstore-adapter

gha_language: Python

repo_name: geosolutions-it/django-mapstore-adapter


text:
##Description:

Passwords should never be stored plaintext or in a reversible format on the application. Whenever an attacker hacks
into the applications SQL database the passwords are directly compromised. In the case of
pre-filled forms in the application, an attacker could also hijack the credentials by badly
configured CORS rules or XSS attacks.

##Mitigation:

Verify that forms containing credentials are not filled in by
the application. Pre-filling by the application implies that
credentials are stored in plaintext or a reversible format,
which is explicitly prohibited. Passwords should be stored by preferably PBKDF functions.

PBKDF2 uses a pseudorandom function and a configurable number of iterations to derive a
cryptographic key from a password. Because this process is difficult to reverse
(similar to a cryptographic hash function) but can also be configured to be slow to
compute, key derivation functions are ideally suited for password hashing use cases.

Examples of good ways to store passwords are with, BCRYPT, Blowfish or in some cases SCRYPT
which is a little harder to implement correctly

NOTE: Password pre-filling also happens when using the browsers password manager. However this process is different fromt he context described above since the description above implies an application that pre-filles credentials from the database/localstorage/etc.

gha_language: HTML


text:
Prototypes - Coin Acceptor
==========

Two sample apps that are part of our Coin Acceptor Prototype.

coinAcceptor-arduino is an Arduino app that determines coin type from a Coin Acceptor and sends the info out as serial data

serialcom-cinder is a Cinder app that recieves coin type as serial data and sends out OSC messages to another Cinder graphics app.

More info and full tutorial can be found at: www.redpaperheart.com/blog

repository: redpaperheart/Prototype-Coin-acceptor

repo_name: redpaperheart/Prototype-Coin-acceptor


text:
# Aliyun OpenAPI Meta Data

- 阿里云OpenAPI元数据，目前仅用于[aliyun-cli](https://github.com/aliyun/aliyun-cli)工具的构建，注意此数据目前处于非稳定期，随时可能变动

- This meta data is aliyun OpenAPI products and api information, now is only for [aliyun-cli](https://github.com/aliyun/aliyun-cli) build, the structure is not stable will change further.

repository: aliyun/aliyun-openapi-meta

repo_name: aliyun/aliyun-openapi-meta


text:
# data-with-cache

Implementing data caching in JS applications can make them more
responsive for users, and also more resilient against a poor network
connection or API problems.

The goal of this library is to provide a configurable wrapper for API
calls that provides caching logic, to save you writing this yourself :)

Example below, and check out the
[demo page](http://russellbriggs.co/data-with-cache/demo/).

```ts
function getCompany(companyId: number) {
    return new DataWithCache<Company>({
        strategy: 'cache_first',
        cache: appCache,
        objectType: 'company',
        objectId: String(companyId),
        cacheExpires: 60000,  // 1 minute
        getData: () => api.getCompany(companyId)
    });
}

const company = await getCompany(123).getData();
```

## Currently Included Strategies

### API First

  - Try the API first and wait until `apiTimeout`, or until an error occurs
  - Return API data if successful, and add it to the cache
  - If API throws an error or times out, then return the data from the cache (if present)
  - If no matching data in the cache then throw an error

This strategy is good for when displaying up-to-date information is critical,
but you want your app to keep working offline or with an unreliable / slow network

### Cache First - (stale-while-revalidate)

  - Return the data from the cache first (if present)
  - If there is no matching data in the cache, try the API
  - If the API call is successful, return the data and add it to the cache
  - If the cached data is older than `cacheExpires` ms, contact the API
    asynchronously and get the most up-to-date data

This strategy is best if you want to ensure your UI is rendered as quickly as possible, and
you are OK with your users occasionally seeing slightly out-of-date information.

With this strategy, you can still update your UI as soon as the updated information is
received from your API, via the `onRefreshed()` event handler.

## Supported Backends

* [In Memory](https://github.com/dupski/data-with-cache/blob/master/src/backends/InMemoryCache.ts)
* [IndexedDB](https://github.com/dupski/data-with-cache/blob/master/src/backends/IndexedDBCache.ts)
* Any cache that can be accessed via the
  [ICacheBacked interface](https://github.com/dupski/data-with-cache/blob/master/src/types.ts)

# Recent Changes

See the [CHANGELOG](https://github.com/dupski/data-with-cache/blob/master/CHANGELOG.md)

# Examples

## API First

In the example below, we create a utility function that can be called from anywhere
in our application to fetch data. Behind the scenes it will automatically return the data from
cache if the API does not respond within `apiTimeout` milliseconds or if the API
responds with an error.

```ts
import { DataWithCache, IndexedDBCache } from 'data-with-cache';
import * as api from './api';

const cache = new IndexedDBCache('app_cache');

export function getSeminarAttendees(seminarId: number) {
    return new DataWithCache<api.IAttendee[]>({
        strategy: 'api_first',
        cache,
        objectType: 'seminarAttendees',
        objectId: String(seminarId),
        apiTimeout: 5000,
        getData: () => api.getSeminarAttendees(seminarId)
    });
}

// Somwehere else in your application, you can get the data like this:

(async () => {

    const seminarId = 123;
    const attendees = await getSeminarAttendees(seminarId).getData();

    console.log('Attendees:', attendees);

})();
```

## Cache First

In the example below, we create a utility function that can be called from anywhere
in our application to fetch data. If there is matching data in the cache, it will
be returned immediately and displayed to the user.

If the cached data is older than `cacheExpires` milliseconds then DataWithCache will
fetch the most up-to-date data asynchronously. When this happens, the
`onRefreshing()` callback will be called, which you can use to show a "refreshing"
spinner to the user to indicate the displayed data may be updated shortly.

When the refresh is completed the `onRefreshed()` callback will be called with the
most recent data, which is then displayed in the UI.

```ts
import { DataWithCache, IndexedDBCache } from 'data-with-cache';
import * as api from './api';

const cache = new IndexedDBCache('app_cache');

export function getSeminarAttendees(seminarId: number) {
    return new DataWithCache<api.IAttendee[]>({
        strategy: 'cache_first',
        cache,
        objectType: 'seminarAttendees',
        objectId: String(seminarId),
        cacheExpires: 300000,  // 5 minutes
        getData: () => api.getSeminarAttendees(seminarId)
    });
}

// Somwehere else in your application, you can get the data like this:

(async () => {

    const seminarId = 123;
    const attendeesQuery = getSeminarAttendees(seminarId);

    // Register event handlers so we can update our UI if data
    // is being refreshed asynchronously.
    attendeesQuery.onRefreshing = () => {
        ui.showRefreshingIndicator(true);
    }
    attendeesQuery.onRefreshed = (data: api.IAttendees[]) => {
        ui.showRefreshingIndicator(false);
        ui.showAttendeeData(data);
    }

    // getData() will return immediately if there is a cache match
    attendeesData = await attendeesQuery.getData();
    ui.showAttendeeData(attendeesData);

})();
```

# API

## `DataWithCache` parameters

```ts
const dataWithCache = new DataWithCache({ ...parameters });
```

Required Parameters:

* **`strategy:`** - either `api_first` or `cache_first`
* **`cache:`** - a JavaScript object that implements the
  [ICacheBacked interface](https://github.com/dupski/data-with-cache/blob/master/src/types.ts)
* **`objectType:`** - a string representing the type of data you are caching (e.g. `company` or `region`)
* **`objectId:`** - a unique ID for the data being cached. Used in combination with `objectType` to query the cache
* **`getData:`** - a JavaScript `function` that returns a `Promise` that either resolves with the
   required data from your data source, or rejects with an error.

Optional Parameters:

* **`apiTimeout:`** - Time (in milliseconds) to wait for the `getData()` function to resolve. Default is 5 seconds.
* **`cacheTimeout:`** - Time (in milliseconds) to wait for the cache to return a result. Default is 1 second.
* **`cacheExpires:`** - Max age (in milliseconds) of a cached record, before it needs to be refreshed. If it is
  not set, cache entries never expire. Set to `0` to expire the cache immediately. Default is not set.
* **`onError:`** - A function with the signature `(error: Error, level: 'warning' | 'error') => void` which
  is called with the details of any errors returned by the `getData()` function and the `cache`.
* **`debug:`** - Set to `true` to enable verbose console output from the cache functions.

## `DataWithCache` properties & methods

```ts
const dataWithCache = new DataWithCache({ ...parameters });

// These event handlers need to be set before calling getData()
dataWithCache.onRefreshing = () => {
    console.log('A refresh is happening asynchronously...');
}
dataWithCache.onRefreshed = (data) => {
    console.log('A refresh completed. The new data is:', data);
}

const data = await dataWithCache.getData();  // Returns data (either from cache or API)
```

# Contributing

PRs welcome!

# License

MIT

repository: dupski/data-with-cache

repo_name: dupski/data-with-cache


text:
<!--
The MIT License (MIT)

Copyright (c) 2014, 2015 IBM Corporation
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.
-->

# NavCog User Guide

## Usage of NavCog
1. Tap “Choose Map” to show available navigation maps
2. Select the map where you are and tap “Update” -> wait for loading (a few seconds)
3. Set the current place to “From” and the destination to “To”
4. Head to XXX and tap “Initialize Orientation”
5. Tap “Start Navigation” to start navigation

## Select Map View
Please select a map from the list.
There are maps in the public map list and maps in a private map.

### Update button
Download the latest public map list from the NavCog server and update the list.

## Route Setting View
![Screen Short](images/main_view.png)

### Initialize Orientation button
You need to initialize orientation for the first use. Please ask your admin how to set the orientation.

### Start Navigation button
Start navigation from **from** place to **to** place.

### From, To picker
Please select your start location and destination.

### Speech option
Speak navigation command

### Click option
Provide click sound for navigation

### Speech rate
You can change speech rate as Normal / Fast

### Choose Map button
You can change the map


text:
# TODO

* separate settings
  * fisheye vs equirectangular vs flat
  * flat/180/360
  * TB/BT/LR/RL
  * yFlip
  * scale
* save per video metadata
  * guess from filename if not exists SBS, LR, RL, 180, 360
* add hover for slider (show time above)
* drag with grab
* make it keep scroll position
* add modes
  * find videos
    * cubemap
    * pin at top (TFD?)
    * flip left/right (just mirror?)
    * flip top/bottom
* remove unused oculus stuff
* make both controllers work at the same time
* support Vive
* support Index
* fix cue position (seems like a bug in AVPro or bad data)

# Done

* handle fisheye
* add fps
* add quit icon
* add 1/2 speed
* add next/prev
* add time display
* que with thumbsticks
* make select 1 click
* scroll with thumb
* make hands disappear if no UI

repository: greggman/vrvp

repo_name: greggman/vrvp


text:
## Hardware store elimination
Writing data to memory is a very expensive operation for modern CPUs. They thus leverage multi-level cache hierarchies
that try to delay or avoid writes to RAM as long as possible. When there is no space in a cache for a cache line and the
cache line has been modified, it needs to be evicted and written back to a higher cache level or to RAM.

Intuitively, this process does not depend on the actual value of the cache line, it should be just opaque data for the processor.
However, Travis Downs [has found out](https://travisdowns.github.io/blog/2020/05/13/intel-zero-opt.html) that client Skylake Intel
microarchitectures (Skylake, Kaby Lake, Coffee Lake, Whiskey Lake, ...) seem to use a peculiar heuristic that sometimes skips
the writeback to memory when the value of the cache line is exactly zero. (Repeatedly) writing zeros to memory can thus
potentially achieve higher bandwidth than writing other values.

Usage:
```bash
$ hardware-store-elimination <size> <value>
```

This program will create an array with `size` bytes. It will then repeatedly write the given `value` to all elements of
the array and report the achieved bandwidth (how many MiB/s were transferred). If you have a Skylake client microarchitecture,
you should see that once you get to L2/L3/RAM size, writing zeros is faster than writing other values.

You can observe this effect by checking the `l2_lines_out.silent` and `l2_lines_out.non_silent` performance counters, which
measure how many times was some cache line evicted (`non_silent`) or dropped (`silent`) from the L2 cache.

```bash
$  perf stat -e l2_lines_out.silent,l2_lines_out.non_silent hardware-store-elimination 8388608 1
16694.3
        1 445 170    l2_lines_out.silent
      130 429 669    l2_lines_out.non_silent

$  perf stat -e l2_lines_out.silent,l2_lines_out.non_silent hardware-store-elimination 8388608 0
19524.3
       38 832 738    l2_lines_out.silent
       92 787 097    l2_lines_out.non_silent
```

You can run the Python benchmark script to plot how the write bandwidth depends on the written value.
```bash
$ python3 benchmark.py <path-to-executable>
```

You can find detailed observations about this effect at Travis Downs' blog:
- https://travisdowns.github.io/blog/2020/05/13/intel-zero-opt.html
- https://travisdowns.github.io/blog/2020/05/18/icelake-zero-opt.html

repository: frozenca/hardware-effects

repo_name: frozenca/hardware-effects


text:
**Draft**

This is a first attempt at a table of content for a more exhaustive technical
documentation of Grin (we'd call it a white paper if we had to do an ICO).
This should get progressively filled up, until we're ready to advertize it
more widely.

* What is Grin?
* [Introduction to Mimblewimble](intro.md)
* Cryptographic Primitives
  * Pedersen Commitments
  * Aggregate (Schnorr) Signatures
    * Bulletproofs
* Block and Transaction Format
  * Transaction
    * Input, output
    * Kernel
  * Block
    * Header
    * Body
    * Compact Block
* Chain State and Merkle Mountain Range
  * Motivation
  * [Merkle Mountain Range](mmr.md)
  * [State and Storage](state.md)
  * [Fast Sync](fast-sync.md)
  * Merkle Proofs
* Proof of Work
  * Cuckoo Cycle
  * Difficulty Algorithm
* Wire protocol
  * Seeding and Sync
  * Propagation
  * Low-level Messages
* Dandelion & Aggregation
* Building Transactions
* Important Parameters
  * Fees and Transaction Weight
  * Reward and Block Weight
* [Smart Contracts](contracts.md)

repository: mimblewimble/grin

gha_language: Rust

repo_name: mimblewimble/grin


text:
# Base16 Sass

The Base16 color schemes (107) converted to Sass modules, ready to be used in projects.

- https://github.com/tajmone/Base16-Sass

Copyright © 2019, [Tristano Ajmone].

-----

**Table of Contents**

<!-- MarkdownTOC autolink="true" bracket="round" autoanchor="false" lowercase="only_ascii" uri_encoding="true" levels="1,2,3" -->

- [Introduction](#introduction)
    - [The YAML Schemes](#the-yaml-schemes)
    - [The SCSS Schemes](#the-scss-schemes)
    - [Bare vs Named Schemes](#bare-vs-named-schemes)
- [Building the SCSS Modules](#building-the-scss-modules)
- [System Requirements](#system-requirements)
- [About Base16](#about-base16)
- [Credits and License](#credits-and-license)

<!-- /MarkdownTOC -->

-----

# Introduction

Since I work often on documentation projects that involve syntax highlighting, and because the Base16 color schemes collection is so beautiful, I decided to create this repository so that I would always have a Sass module ready available for every Base16 scheme.

## The YAML Schemes

This projects automates the conversion of all 107 Base16 schemes from YAML to Sass/SCSS, via Mustache templates.

- [`/schemes/`][schemes] — source YAML Base16 schemes.

## The SCSS Schemes

All the Base16 schemes are already available in the repository as Sass/SCSS modules, there is no need to convert them from YAML (but there is a [`build.sh`][build] script for doing it, if you need to).

There are two different Sass versions for each scheme:

- [`/scss-bare/`][scss-bare] — SCSS with fixed variables naming.
- [`/scss-named/`][scss-named] — SCSS with variables named after the scheme.

Every module is named after its original YAML scheme:

|        yaml       |        scss        |
|-------------------|--------------------|
| `<filename>.yaml` | `_<filename>.scss` |

## Bare vs Named Schemes

The Sass modules in the `scss-bare/` folder define the color schemes using a fixed variable naming convention:

```scss
$base00: #171c19;
$base01: #232a25;
$base02: #526057;
$base03: #5f6d64;
$base04: #78877d;
$base05: #87928a;
$base06: #dfe7e2;
$base07: #ecf4ee;
$base08: #b16139;
$base09: #9f713c;
$base0A: #a07e3b;
$base0B: #489963;
$base0C: #1c9aa0;
$base0D: #478c90;
$base0E: #55859b;
$base0F: #867469;
```

While the modules in the `scss-named/` folder include the color scheme name in the variables identifiers:

```scss
$Atelier-Savanna-00: #171c19;
$Atelier-Savanna-01: #232a25;
$Atelier-Savanna-02: #526057;
$Atelier-Savanna-03: #5f6d64;
$Atelier-Savanna-04: #78877d;
$Atelier-Savanna-05: #87928a;
$Atelier-Savanna-06: #dfe7e2;
$Atelier-Savanna-07: #ecf4ee;
$Atelier-Savanna-08: #b16139;
$Atelier-Savanna-09: #9f713c;
$Atelier-Savanna-0A: #a07e3b;
$Atelier-Savanna-0B: #489963;
$Atelier-Savanna-0C: #1c9aa0;
$Atelier-Savanna-0D: #478c90;
$Atelier-Savanna-0E: #55859b;
$Atelier-Savanna-0F: #867469;
```

... where the variable identifier is taken from the scheme name (not the filename) and spaces are substituted with hyphens.

The former are useful in Sass projects which rely on a fixed naming convention for the Base16 variables, which is more than enough if your project uses a single Base16 scheme, while the latter is useful when you need multiple Base16 schemes to cohexist and be globally available with unique identifiers.

Sometimes it's easier to work with the former, especially for projects using a single Base16 scheme, as you only need to replace the module defining the actual colors to affect results, without having to rename variables, or you can just keep redefining the scheme variables during compilation, to produce different results using the same mixins or file imports.

But other times the context will require the scheme variables to be kept available during the whole Sass compilation, so you'll need the latter if you're working with multiple schemes and you want them to be uniquely identified and persistent.

Whichever your needs, this repository can provide you with a quick drop-in Sass/SCSS module for every Base16 scheme.

# Building the SCSS Modules

To convert the Base16 YAML schemes, I've taken a custom approach instead of using one of on the official [base16 builders]. This approach has both pros and cons, so others might prefer to use the mustache templates of this project with a Base16 builder instead.

There were various reasons why I didn't want to use an official base16 builder:

1. I dediced to add a extra `url` variable to the YAML schemes, pointing to the repository the scheme was downloaded from, so that it could be included in the final SCSS module.

2. My mustache templates are designed for the original (old) base16 naming convention — which is the one still used in most color schemes found around the web — while most builders use the newer conventions (base16 `v0.8.0`–`v0.9.0`), which rely on a different naming convention for template variables.

3. I had already done the above steps for the __[highlight-extras]__ project, so the base material was ready for reuse — I only needed to add an extra `id` key to each scheme, to be used for naming the variables.

For the above reasons, a custom workflow seemed a better idea. The downside is that the base16 schemes have to be updated manually, by checking from time to time if new schemes were added to the list.

In the future, I might try to find a better solution; but right now I'm quite satisfied that this approach allowed the creation of 107 Base16 Sass modules at once, without too much effort or the need to install extra tools.

# System Requirements

If you're only interested in using the Sass schemes, you don't need to setup anything, for these are already available in the repository. But if you want to convert them yourself, just run the build script:

- [`./build.sh`][build]

You'll need two Node.js CLI tools:

- __[mustache.js]__ (by Jan Lehnardt) — JavaScript implementation of [mustache].
- __[yaml-utils]__ (by Christopher Brown) — to convert from YAML to JSON.

In order to build the themes via the scripts in this project, you'll need to install these two packages globally on your machine (obviously, you'll need [Node.js] too).

Of course, you can instead use any mustache tool of your choice to convert the schemes, the `*.mustache` templates will work with any mustache implementation.

# About Base16

- http://chriskempson.com/projects/base16/

From the [base16 homepage]:

> \[Base16 is\] an architecture for building themes based on carefully chosen syntax highlighting using a base of sixteen colours. Base16 provides a set of guidelines detailing how to style syntax and how to code a _builder_ for compiling base16 _schemes_ and _templates_.

# Credits and License

The YAML Base16 schemes inside the [`schemes/`][schemes] folder were taken and adapted from [Chris Kempson]'s __[Base16 Builder]__ project (deprecated), with the exception of a few schemes which were colleted from other sources (indicated in the `url` key added to every scheme).

This project is therefore released under the same license of the original schemes, the MIT License:

```
MIT License

Copyright (c) 2019 Tristano Ajmone<EMAIL_ADDRESS>https://github.com/tajmone/Base16-Sass

Copyright (c) 2012 Chris Kempson (http://chriskempson.com)
https://github.com/chriskempson/base16-builder

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.
```

<!-----------------------------------------------------------------------------
                               REFERENCE LINKS
------------------------------------------------------------------------------>

<!--------------------------- Internal Repo Links ---------------------------->

<!-- files  -->

[build]: ./build.sh "View file"

<!-- folders -->

[schemes]: ./schemes/ "Navigate to folder"
[scss-bare]: ./scss-bare/ "Navigate to folder"
[scss-named]: ./scss-named/ "Navigate to folder"

<!--------------------------- External References ---------------------------->

[mustache]: https://mustache.github.io/ "Visit mustache website"

<!-- Base16 Builder Upstream -->

[Base16 Builder]: https://github.com/chriskempson/base16-builder "Visit the Base16 Builder on GitHub"

<!-- Base16 Official -->

[base16 homepage]: http://chriskempson.com/projects/base16/ "Visit base16 homepage"
[base16 repository]: https://github.com/chriskempson/base16 "Visit base16 project on GitHub"
[base16 project]: https://github.com/chriskempson/base16 "Visit base16 project on GitHub"
[base16 builders]: https://github.com/chriskempson/base16#builder-repositories
[Base16 Styling Guidelines]: http://chriskempson.com/projects/base16/#styling-guidelines "Read the Base16 Styling Guidelines"

[Scheme Repositories]: https://github.com/chriskempson/base16#scheme-repositories "See the list of Scheme Repositories mentioned in the base16 official project"
[dce99f6]: https://github.com/chriskempson/base16/blob/dce99f6/README.md#scheme-repositories

[highlight-extras]: https://gitlab.com/tajmone/highlight-extras "View the highlight-extras repository on GitLab"

<!-- Dependencies -->

[mustache.js]: https://www.npmjs.com/package/mustache "Visit 'mustache.js' page on NPM"
[yaml-utils]: https://www.npmjs.com/package/yaml-utils "Visit 'yaml-utils' page on NPM"
[Node.js]: https://nodejs.org/ "Visit Node.js website"

<!-- People -->

[Chris Kempson]: https://github.com/chriskempson "View Chris Kempson's GitHub profile"
[Tristano Ajmone]: https://github.com/tajmone "View Tristano Ajmone's GitHub profile"

<!-- EOF -->


text:
## NEWS HIGLIGHTS
# built by Mariam Omar
##Description
*This is an app that allows you to view news sources from various and most famous news channels and the articles that are shown according to business,general,sports and entertainment news
##User Specification
*Landing page has a list of all the news sources available and a brief description of each source.
*The news sources are listed alphabetically.
*Users are able to click on each news source and get alistof all the articles of that particular news source.
*A user can read that particular news item from the source directly.
##SetUp and Installation requirements
*Launch The app directly from
## Technologies Used
* ```Python3.6```
* ```Flask```
* ```News API`
## License
MIT ©2017 **[Mariam Omar]()