open-index/open-npm huggingface dataset:
npm package: @jpweeks/gltf-loader
Description: A Webpack loader for glTF assets. Automatically bundles all referenced files.
Author: Jay Weeks
Latest version: 2.0.0

# Webpack glTF Loader

A Webpack loader for __glTF__ assets. Automatically bundles all referenced files.

This loader is based on [MONOGRID/gltf-loader-2](https://github.com/MONOGRID/gltf-loader-2).

## Webpack configuration 

``` js
rules: [
  // IMPORTANT: if you have a loader for Image files (you would, normally)
  // you NEED to add an exclude option IN IT for GLTF images
  {
    // following is an example of YOUR loader config
    test: /\.(png|jpe?g|gif)(\?.*)?$/,
    // here I decided to put all my gltf files under a folder named 'gltf'
    // so I added and exclude rule to my existing loader
    exclude: /gltf/, // only add this line
    // (etc)
    loader: 'url-loader',
    options: {
      limit: 10000,
      name: 'img/[name].[hash:7].[ext]'
    }
  },
  // GLTF configuration: add this to rules
  {
    // match all .gltf files
    test: /\.(gltf)$/,
    loader: '@jpweeks/gltf-loader'
  },
  {
    // here I match only IMAGE and BIN files under the gltf folder
    test: /gltf.*\.(bin|png|jpe?g|gif)$/,
    // or use url-loader if you would like to embed images in the source gltf
    loader: 'file-loader',
    options: {
      // output folder for bin and image files, configure as needed
      name: 'gltf/[name].[hash:7].[ext]'
    }
  }
  // end GLTF configuration
]
```

## Usage Example in Three.js

 ``` js
 // please notice the file and all its dependencies 
 // are under a folder named 'gltf' as per webpack config
import gltfFile from 'assets/gltf/some.gltf';
// per configuration only the GLTF json het embedded in the source
// .bin and .png images are processed and outputted by webpack

var loader = new GLTFLoader()
loader.parse(shieldGLTF, '', (gltf) => {
  // here we go
  let scene = gltf.scene
})
 ```
npm package: @jpweeks/html-webpack-inline-plugin
Description: [![NPM Version](https://img.shields.io/npm/v/html-webpack-inline-plugin.svg?style=flat-square)](https://www.npmjs.com/package/html-webpack-inline-plugin)
Author: Jay Weeks
Latest version: 0.1.1

# html-webpack-inline-plugin

[![NPM Version](https://img.shields.io/npm/v/html-webpack-inline-plugin.svg?style=flat-square)](https://www.npmjs.com/package/html-webpack-inline-plugin)

> Inline all `<script>`, `<link>` and `<img>` tags that contain the `inline` attribute with [inline-source](https://github.com/popeindustries/inline-source).

## Installation


```shell
npm install --save-dev html-webpack-inline-plugin
```

## Basic Usage
Require the plugin in your webpack config:

```javascript
var HtmlWebpackInlinePlugin = require('html-webpack-inline-plugin');
```

Add the plugin to your webpack config as follows:

```javascript
plugins: [
  new HtmlWebpackPlugin(),
  new HtmlWebpackInlinePlugin()
]  
```

Add the tag to your html template as follows:

```html
<!DOCTYPE html>
<html>
  <head>
    <script inline src="web_modules/lib/lib.js"></script>
  </head>
  <body>
  </body>
</html>
```

# Inspired by
[gulp-inline-source](https://github.com/fmal/gulp-inline-source)

# License

This project is licensed under [MIT](https://github.com/jantimon/html-webpack-plugin/blob/master/LICENSE).
npm package: @jpweeks/parse-obj
Description: Parses .OBJ formatted meshes
Author: Mikola Lysenko
Latest version: 0.1.0

parse-obj
=========
A simple parser for .OBJ mesh files.

## Example

```javascript
var fs = require("fs")
var parseOBJ = require("parse-obj")

parseOBJ(fs.createReadStream("mesh.obj"), function(err, result) {
  if(err) {
    throw new Error("Error parsing OBJ file: " + err)
  }
  console.log("Got mesh: ", result)
})
```

### `require("parse-obj")(stream, cb(err, result))`
Parses a read stream into a .OBJ format mesh

* `stream` is a read stream
* `cb` is a callback that gets executed once the stream is parsed.  The `result` object is a structure with the following data:

  + `vertexPositions` an array of vertex position data
  + `vertexNormals` an array of vertex normal data
  + `vertexUVs` an array of vertex UV coordinates
  + `facePositions` an array of indices for face positions
  + `faceNormals` an array of indices for face normals
  + `faceUVs` an array of indices for face texture coordinates
  + `linePositions` an array of indices for line positions


## Credits
(c) 2013 Mikola Lysenko. MIT License
npm package: @jpweeks/rstats
Description: JavaScript Performance Monitor
Author: Jaume Sanchez
Latest version: 1.2.0

# rStats

rStats aims to provide a way of measuring and visualizing performance of your code, mainly in apps based on an update loop, like games or interactive experiences.

You can read more here [Introduction and demos](http://spite.github.io/rstats)

# Credits

Jaume Sanchez Elias [@thespite](http://www.twitter.com/thespite)  
[www.clicktorelease.com](http://www.clicktorelease.com)
npm package: @jpweeks/sprite-loader
Description: A Webpack loader for sprite assets. Automatically bundles all referenced files.
Author: Jay Weeks
Latest version: 0.2.0

# Webpack Sprite Loader

A Webpack loader for sprite assets generated with [__Texture Packer__](https://www.codeandweb.com/texturepacker) using the _Phaser 3_ preset. Automatically bundles all referenced files.
npm package: @jpweeks/static-module
Description: convert module usage to inline expressions
Author: James Halliday
Latest version: 1.6.0

# static-module

convert module usage to inline expressions

# example

Here's a simplified version of the [brfs](https://npmjs.org/package/brfs) module
using static-module.

brfs converts `fs.readFileSync(file)` calls to inline strings with the contents
of `file` included in-place.

``` js
var staticModule = require('static-module');
var quote = require('quote-stream');
var fs = require('fs');

var sm = staticModule({
    fs: {
        readFileSync: function (file) {
            return fs.createReadStream(file).pipe(quote());
        }
    }
}, { vars: { __dirname: __dirname + '/brfs' } });
process.stdin.pipe(sm).pipe(process.stdout);
```

input:

```
$ cat brfs/source.js
var fs = require('fs');
var src = fs.readFileSync(__dirname + '/x.txt');
console.log(src);
```

output:

```
$ node brfs.js < brfs/source.js 

var src = "beep boop\n";
console.log(src);
```

# methods

``` js
var staticModule = require('static-module')
```

## var sm = staticModule(modules, opts={})

Return a transform stream `sm` that transforms javascript source input to
javascript source output with each property in the `modules` object expanded in
inline form.

Properties in the `modules` object can be ordinary values that will be included
directly or functions that will be executed with the [statically
evaluated](https://npmjs.org/package/static-eval) arguments from the source
under an optional set of `opts.vars` variables.

Property functions can return streams, in which case their contents will be
piped directly into the source output.

Otherwise, the return values of functions will be inlined into the source in
place as strings.

Use `opts.varModules` to map whitelisted module names to definitions that can be
declared in client code with `var` and will appear in static expressions like
`opts.vars`.

For example, to make this code with `path.join()` work:

``` js
var fs = require('fs');
var path = require('path');
var src = fs.readFileSync(path.join(__dirname, 'x.txt'), 'utf8');
console.log(src);
```

you can do:

``` js
var staticModule = require('static-module');
var quote = require('quote-stream');
var fs = require('fs');

var sm = staticModule({
    fs: {
        readFileSync: function (file) {
            return fs.createReadStream(file).pipe(quote());
        }
    },
    varMods: { path: require('path') }
}, { vars: { __dirname: __dirname + '/brfs' } });
process.stdin.pipe(sm).pipe(process.stdout);
```

# install

With [npm](https://npmjs.org) do:

```
npm install static-module
```

# license

MIT
npm package: @jpweeks/tap-browser-el
Description: A tap/tape reporter which adds a dom element to the dom and can be styled easily
Author: Mikko Haapoja
Latest version: 2.0.1

# tap-browser-el

[![experimental](http://badges.github.io/stability-badges/dist/experimental.svg)](http://github.com/badges/stability-badges)

![tap-brower-el default stypes](images/defaultStyles.jpg)

A tap/tape reporter which adds a dom element to the dom

## Usage

[![NPM](https://nodei.co/npm/tap-browser-el.png)](https://www.npmjs.com/package/tap-browser-el)

`tap-browser-el` will override `console.log` and watch what's being pushed to it and parse any tap/tape content.

Example:
```javascript
require('tap-browser-el')( {
    // you can optionally pass in el
    // by default a <div> will be created on body
    el: someDomElementWhichTapContentWillBeWrittenTo,

    // if you want tap output to console pass in true
    // if you don't then pass in false
    outPutToConsole: true,

    // you can pass in styles to override default styles
    // if css is not passed default styles will be applied
    // 
    // to apply no inline styles pass `false`
    css: {

        // pass in selector to apply css to parts
        // may seem redundant but it makes this module
        // more 
        '.tap-test.pass': {
            background: '#0F0'
        },

        '.tap-test.fail': {
            background: '#F00'
        }
    },

    // this is a callback you can pass for when one test is finished one part
    // of the test
    onFinishedTestPart: function() {}.

    // this is a callback you can pass for when one test is finished
    onFinishedTest: function() {},

    // this is a callback you can pass for when everything is finished
    onFinished: function() {}
});
```

If you want to see more examples check the [test folder](./test/).

## License

MIT, see [LICENSE.md](http://github.com/Jam3/tap-browser-el/blob/master/LICENSE.md) for details.
npm package: @jpweeks/three.proton
Description: three.proton is a magical 3d particle engine using [three.js]
Author: a-jie
Latest version: 0.1.7

three.proton
======
three.proton is a magical 3d particle engine using [three.js](https://github.com/mrdoob/three.js). It is based on the [Proton](https://github.com/a-jie/Proton) Engine library. It inherited Proton's most api.<br>
I think it is the simplest three.js particle engine.Check out examples at https://a-jie.github.io/three.proton/<br>

## Features
- Four kinds of renderers
  - MeshRender 
  - SpriteRender 
  - PointsRender 
  - CustomRender 

- Three kinds of emitters which can simulate many different physical effects
  - Emitter 
  - BehaviourEmitter 
  - FollowEmitter 
  
- Perfectly compatible with the three.js library. 

#### It was very, very easy to use

## Installation

#### Install using npm 
[![anix](https://nodei.co/npm/three.proton.js.png)](https://npmjs.org/package/three.proton.js)

``` 
npm install three.proton.js --save
... 
import Proton from 'three.proton.js';
```

#### Include in html
``` 
<script type="text/javascript" src="js/three.proton.min.js"></script> 
```

## Usage
```javascript
var proton = new Proton();
var emitter = new Proton.Emitter();

//setRate
emitter.rate = new Proton.Rate(new Proton.Span(4, 16), new Proton.Span(.01));

//addInitialize
emitter.addInitialize(new Proton.Position(new Proton.PointZone(0, 0)));
emitter.addInitialize(new Proton.Mass(1));
emitter.addInitialize(new Proton.Radius(6, 12));
emitter.addInitialize(new Proton.Life(3));
emitter.addInitialize(new Proton.V(45, new Proton.Vector3D(0, 1, 0), 180));

//addBehaviour
emitter.addBehaviour(new Proton.Alpha(1, 0));
emitter.addBehaviour(new Proton.Scale(.1, 1.3));

var color1 = new THREE.Color();
var color2 = new THREE.Color();
var colorBehaviour = new Proton.Color(color1, color2);
emitter.addBehaviour(colorBehaviour);
emitter.emit();

//add emitter
proton.addEmitter(emitter);

//add renderer
proton.addRender(new Proton.SpriteRender(scene));
```

## Building three.proton
Node is a dependency, use terminal to install it with with:<br>
`git clone git://github.com/a-jie/three.proton.git`<br>
Then navigate to the build directory by running:<br>
`cd ./build`<br>
Finally run the build command:<br>
`node build.js`

## License
Proton is released under the MIT License. http://www.opensource.org/licenses/mit-license
npm package: @jpweeks/typedarray-pool
Description: Reuse typed arrays
Author: Mikola Lysenko
Latest version: 2.0.0

typedarray-pool
===============
A global pool for typed arrays.

[![testling badge](https://ci.testling.com/mikolalysenko/typedarray-pool.png)](https://ci.testling.com/mikolalysenko/typedarray-pool)

[![build status](https://secure.travis-ci.org/mikolalysenko/typedarray-pool.png)](http://travis-ci.org/mikolalysenko/typedarray-pool)

# Example

```javascript
var pool = require("typedarray-pool")

//Allocate a buffer with at least 128 floats
var f = pool.malloc(128, "float")

// ... do stuff ...

//When done, release buffer
pool.free(f)
```

# Install

    npm install typedarray-pool

# API

```javascript
var pool = require("typedarray-pool")
```

### `pool.malloc(n[, dtype])`
Allocates a typed array (or ArrayBuffer) with at least n elements.

* `n` is the number of elements in the array
* `dtype` is the data type of the array to allocate.  Must be one of:

  + `"uint8"`
  + `"uint16"`
  + `"uint32"`
  + `"int8"`
  + `"int16"`
  + `"int32"`
  + `"float"`
  + `"float32"`
  + `"double"`
  + `"float64"`
  + `"arraybuffer"`
  + `"data"`
  + `"uint8_clamped"`
  + `"buffer"`

**Returns** A typed array with at least `n` elements in it.  If `dtype` is undefined, an ArrayBuffer is returned.

**Note**  You can avoid the dispatch by directly calling one of the following methods:

* `pool.mallocUint8`
* `pool.mallocUint16`
* `pool.mallocUint32`
* `pool.mallocInt8`
* `pool.mallocInt16`
* `pool.mallocInt32`
* `pool.mallocFloat`
* `pool.mallocDouble`
* `pool.mallocArrayBuffer`
* `pool.mallocDataView`
* `pool.mallocUint8Clamped`

### `pool.free(array)`
Returns the array back to the pool.

* `array` The array object to return to the pool.

**Note** You can speed up the method if you know the type of array before hand by calling one of the following:

* `pool.freeUint8`
* `pool.freeUint16`
* `pool.freeUint32`
* `pool.freeInt8`
* `pool.freeInt16`
* `pool.freeInt32`
* `pool.freeFloat`
* `pool.freeDouble`
* `pool.freeArrayBuffer`
* `pool.freeDataView`
* `pool.freeUint8Clamped`
* `pool.freeBuffer`

### `pool.clearCache()`
Removes all references to cached arrays.  Use this when you are done with the pool to return all the cached memory to the garbage collector.

# Credits
(c) 2014 Mikola Lysenko. MIT License
npm package: @jpwilliams/gitree
Description: Print a directory tree that shows Git status and ignores files dictated by .gitignore.
Author: Jack Williams
Latest version: 1.5.1

# @jpwilliams/gitree

Print a directory tree that shows Git status and ignores files dictated by `.gitignore`.

``` sh
$ npm i -g @jpwilliams/gitree
$ gitree

# OR

$ npx @jpwilliams/gitree
```

<p align="center">
  <img src="https://user-images.githubusercontent.com/1736957/65135842-8783e780-d9fe-11e9-887b-3e04381795ac.png">
</p>

# What?

`gitree` works very similarly to [tree](https://linux.die.net/man/1/tree) but only lists files related to the current git repository.

Like Git, `gitree` only tracks _files_, so empty directories will never be listed. If you wish to push an empty folder to a Git repository, add an empty `.gitignore` or `.gitkeep` file to the directory and commit it.

# What does it show?

`gitree` shows any files that your repository's `.gitignore` files allows you to see, marking them with useful statuses like the ones in the screenshot above.

# What if it's not a Git repository?

It won't work. You must be somewhere within a Git repository to list any files. If you just want a basic tree view _without_ Git integration, consider the built-in `tree` command for Linux/Windows or the [`tree` homebrew formula](http://brewformulas.org/Tree) for Mac OSX.

# What else can it do?

Just this stuff:

``` 
Usage: gitree [options] [dir]


Options:

  -V, --version           output the version number
  -m, --modified          only show modified files
  -t, --tracked           only show tracked files
  -c, --collapse          collapse directory nodes that contain a single child
  -d, --devicons          print matching devicons next to files
  -I, --ignore <pattern>  do not list files that match the given pattern
  -h, --help              output usage information
```

_Note that for devicons to work, you must have a font with devicon glyphs installed. A good place to start is [Nerd Fonts](https://github.com/ryanoasis/nerd-fonts)._

# Can it get any cooler?

There's a built-in alias, `gt`. Fantabulous, eh?
npm package: @jpwilliams/microload
Description: Load a path as an object.
Author: Jack Williams
Latest version: 0.0.3

# microload

A simplified version of [`microboot`](https://github.com/jpwilliams/microboot) and [`microloader`](https://github.com/jpwilliams/microloader) that synchronously loads a given path as an object.

# Key features

- Requires and imports entire directories
- Ignores hidden files

# Usage

``` sh
yarn add microload
```

``` js
const { microload } = require('microload')
const lib = microload('./lib')
```

Based on the following tree structure, `lib` would now be:

```
.
└── lib
    ├── config
    │   ├── creds.js
    │   └── tokens.json
    ├── getter.js
    ├── parser.js
    └── utils
        ├── loadMongo.js
        ├── loadRedis.js
        └── .loadRethink.js
```

``` json
{
  "config": {
    "creds": ...,
    "tokens": ...
  },
  "getter": ...,
  "parser": ...,
  "utils": {
    "loadMongo": ...,
    "loadRedis": ...
  }
}
```
npm package: @jpwilliams/waitgroup
Description: A tiny version of Golang's WaitGroup with typings, promises, and zero dependencies.
Author: Jack Williams
Latest version: 2.1.1

# @jpwilliams/waitgroup

![npm version](https://img.shields.io/npm/v/@jpwilliams/waitgroup) ![Test on push](https://github.com/jpwilliams/waitgroup/workflows/Test%20on%20push/badge.svg) ![Downloads](https://img.shields.io/npm/dm/@jpwilliams/waitgroup)

A tiny version of Golang's [WaitGroup](https://golang.org/pkg/sync/#WaitGroup) for Node.js and the browser with typings, promises, and zero dependencies.

```sh
npm install @jpwilliams/waitgroup
```

```ts
import http from "http";
import { WaitGroup } from "@jpwilliams/waitgroup";

async function main() {
  const wg = new WaitGroup();

  const urls = [
    "http://www.golang.org/",
    "http://www.google.com/",
    "http://www.somestupidname.com/",
  ];

  urls.forEach((url) => {
    // Increment the WaitGroup counter
    wg.add(1);
    // Fetch the URL
    http.get(url, () => {
      // Decrement the counter when the GET is complete
      wg.done();
    });
  });

  // Wait for all HTTP fetches to complete
  await wg.wait();
}

main();
```

For most applications in Node.js, using built-ins like `Promise.all` will work perfectly, but sometimes this can be a really nice abstraction if the promises you have to keep track of are pretty spread out.

See [jpwilliams/waitgroup-deno](https://github.com/jpwilliams/waitgroup-deno) for a [Deno](https://deno.land/) version.