open-index/open-npm huggingface dataset:
npm package: @quozul/canvas-image
Description: A canvas to view image, zoom and pan.
Author: Quozul
Latest version: 0.1.3

# canvas-image
A canvas to view image, zoom and pan.

## Demo
A demo page is available at: https://quozul.github.io/canvas-image/

## Usage

### Vanilla HTML
```html
<canvas-image src="https://quozul.github.io/canvas-image/image-landscape.jpg"></canvas-image>
<script src="https://quozul.github.io/canvas-image/canvas-image.js"></script>
```
> :warning: GitHub Pages is not a CDN, so you should download the `canvas-image.js` file locally!
npm package: @qupa/qupa
Description: Queued Parallelism Language
Latest version: 0.0.3

# Qupa

A compiled programming language based around having individual queues for each thread allowing event and callback driven multithreading behaviour.

## Setup
First you need do install Clang and NPM, both of which are operating system specific.
<details>
	<summary>Unix</summary>
	On unix installation is quite easy. Just run the two lines below in your terminal
	<pre><code>sudo apt-get npm</br>sudo apt-get clang++</code></pre>
</details>
<details>
	<summary>Windows</summary>
	First simply install NodeJS from <a href="https://nodejs.dev">nodejs.dev</a>, then you need to install clang. To install Clang one Windows you need to have MSVC installed first - to do this follow this <a href="https://docs.microsoft.com/en-us/cpp/build/vscpp-step-0-installation">guide</a>, then once MSVC is installed you can simply download the pre-built binary for you computer from <a href="https://releases.llvm.org/download.html">here</a>
</details>

Once that is done, simply run these lines in the folder and now all required files are prepared for your system
```
npm install @qupa/qupa
```

## CLI Ussage
Once you have followed the setup, NPM has registered ``qupa`` as a command that can be used to compile with.
```
qupa {entry_file}
```

## Flags

| Flag | Description |
| :- | :- |
| ``-S {llvm?}`` | The flag specifies not to build a binary, if optional term ``llvm`` is entered it will only output LLVM-IR, otherwise it will output the assembly of the target platform |
| ``-o {file}`` | Specify the output filename from the compiler |
| ``--no-caching`` | Specifies that the compiler should not reuse values cached in registers, and should instead reload any reference values each time they are used |
| ``--execute`` | Specifies that the compiler should not reuse values cached in registers, and should instead reload any reference values each time they are used |
| ``-v`` | Will log out the current version number of the compiler |
npm package: @qupa/uniview
Description: Uniview Language
Latest version: 0.1.0

# Uniview-lang

> View once immutability enabling the safeties of immutable code, while enjoying near procedural performance

The core goal of this language is to implement compile time determined memory managed applications without developers needing to consider memory management. No pointers, no life times, just code.

When any non-primative value is viewed it can no longer be used, this extends to structure attributes. However there is no concept of null or undefined being a value. Undefined is a compile time state and that's it.
```uv
fn main(): int {
	let person = Blank#[Person]();
	print(person.name); // name has now been consumed
	consume(person); // error cannot compose person due to undefined name
}
```

You can also find a few examples in `test/pre-alpha/`.


## Compiler Arguments

| Argument | Use |
| :- | :- |
| `-o {filename}` | The destination file name for the LLVM IR and binary output |
| `-s` | The compilation level to perform `llvm`, `assembly` |
| `--execute` | Executes the binary output after successful compilation |
| `--version` | Prints the version of the compiler |
| `--verifyOnly` | Compiles to LLVM, but does not store the results or compiles further |
| `--compileOnly` | Compiles to binary, but does not execute the result |
| `--opt {num}` | Runs optimisation passes over the output (any number between 0-3 inclusive) |