open-index/open-npm huggingface dataset:
npm package: @jkearl/pratt
Description: Pratt parser builder (along with simple tokenizer)
Author: Jackson Kearl
Latest version: 0.1.1

# PrattParse

## TypeScript implementation of a Pratt parser generator

Inspired by [Pratt Parsers: Expression Parsing Made Easy](http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/).
npm package: @jkearl/tar
Description: Tar utils. Fork of github/thiscouldbebetter/TarFileExplorer
Author: JacksonKearl, thiscouldbebetter
Latest version: 1.0.6

TAR File Explorer
=================

JavaScript module for reading TAR files.

`npm i @jkearl/tar`

See `distro` for example use. 

Fast. Suitable for large TARs (tested up to linux's 1 GB drop, which it opened in about 2s).

### This Fork

Forked to imporove perf and better support distribution as a single file incorporated into a larger appication. This included:
- Removing all rendering code
- Removing all tar writing code
- Removing additions to global prototype objects
- Moving to Uint8Array for bytearrays
- Reducing allocations in reads (the TarFile object is a collection of slices into the original Uint8Array)
- Several bug fixes
- Packaging to expose only a single function for creating a TarFile from a Uint8Array
- Linting tooling and several vscode hooks
npm package: @jkempema/configuration
Description: configuration
Latest version: 1.0.5

# configuration

Library to provide a consistent way of getting and setting configuration values.

## Usage

Load Values

```
import Configuration from 'configuration'

const config = new Configuration();

config.load( {
    something: 'some value',
    somethingElse: "some other value"
} );

const something = config.get( 'something' );
const somethingElse = config.get( 'somethingElse' );
```

Set & Get Values

```
import Configuration from 'configuration'

const config = new Configuration();

config.set( 'something', 'some value' );

const something = config.get( 'something' );

const somethingElse = config.get( 'somethingElse', 'default value' );
```

Listen for Changes
```
import Configuration from 'configuration'

const config = new Configuration();

const removeEventListener = config.addEventListener( 'change', ( key ) => {
    console.log( `config key ${ key } changed to ${ config.get( key ) }` ); 
} );

config.set( 'something', 'some value' );

removeEventListener();
```

## Global Configuration

The Configuration class has a global property to provide a means where configuration settings can accessed across libraries.

```
import Configuration from 'configuration'

const globalConfig = Configuration.global;

const something = globalConfig.getValue( 'something' );
```
npm package: @jkempema/fetch
Description: fetch function that allows middleware.
Latest version: 1.0.4

# fetch

fetch function that allows middleware.

## Usage

```
import fetch from 'fetch';

fetch.applyMiddleware( 
    ( request ) => {  
        request.headers.append( 'authorization', 'bearer ...' );
    },
    async ( request, response ) => {
        const data = await response.clone().json();
    },s
    ( request, error ) => {
        console.error( error );
    } 
);

const response = await fetch( 'http://...', { method: "GET" } );
const data = await response.json();
```
npm package: @jkempema/gulp-sass-npm-importer
Description: importer to get sass files from npm modules
Author: Jamie Kempema
Latest version: 1.0.4

# gulp-sass-npm-importer

Tool to import sass files from npm modules.

## Usage

Gulp

```
var sassNpmImporter = require("gulp-sass-npm-importer");

gulp.task("styles", function() {
    return gulp
        .src("...")
        .pipe(sass({
            ...
            importer: sassNpmImporter
        }))
        .pipe(gulp.dest("..."));
});
```

Sass

```
@import "npm-module-name";  // import all sass files.

@import "npm-module-name/file-name" // import specific sass file. ( Do not include .scss )
```
npm package: @jkempema/messaging
Description: messaging
Latest version: 1.0.7

# messaging

Library to provide publish and subscribe messaging.

## Usage

Publish / Subscribe / Unsubscribe

```
import Dispatcher from 'messaging';

// Create Dispatcher
const dispatcher = new Dispatcher();

// Subscribe ( anonymous function )
const unsubscribe = dispatcher.subscribe( 'test', ( message ) => {
    console.log( message );
} );

// Subscribe ( named function )
const handleMessage = ( message ) => {
    console.log( message );
};

dispatcher.subscribe( 'test', handleMessage );

// Publish Message
dispatcher.publish( 'test', { text: 'some message' } );

// Unsubscribe ( anonymous function )
unsubscribe();

// Unsubscribe ( named function )
dispatcher.unsubscribe( 'test', handleMessage );
```


Defer Message Handling

```
import Dispatcher from 'messaging';

const dispatcher = new Dispatcher();

const unsubscribe = dispatcher.subscribe( 'test', ( message, defer ) => {
    defer( ( done ) => {
        // Do something that may take some time...
        done();
    } );
} );

// Publish Message
dispatcher.publish( 'test', { text: 'some message' } ).then( () => {
        // This will not execute untill all subscribers have processed the message.
} );;

// Unsubscribe 
unsubscribe();
```

## Global Dispatcher

The Dispatcher class has a global property to provide a means where messaging can accessed across libraries.

```
import Dispatcher from 'messaging'

const globalDispatcher = Dispatcher.global;
```
npm package: @jkempema/react-resource
Description: react-resource
Latest version: 1.0.3

# react-resource

React component to provide loading content from configuration. This allows for site content to be swapped at run time, which is useful for supporting multiple languages and making the site more themable.

## Usage

Configure / Render

```
import Configuration from 'configuration';
import Resource from 'react-resource';

// Load Resources Into Global Configuration
Configuration.global.load( {
    'resource.someText': 'Test',
    'resource.someImage':  (
        <svg>
            <text x="0" y="35" fontFamily="Verdana" fontSize="35">
                Test
            </text>
        </svg>
    )
} );

// Render some text setup in configuration
<Resource name='resource.someText' />

// Render some image setup in configuration
<Resource name='resource.someImage' />
```


Default Values

When a resource name is not configured in the global configuration, a child component can be supplied to serve as a default.

```
import Resource from 'react-resource';

// Render some text that is not setup in configuration
<Resource name='resource.someText'>
    Some Default Value
</Resource>

// Render some image that is not setup in configuration
<Resource name='resource.someImage' >
    <svg>
        <text x="0" y="35" fontFamily="Verdana" fontSize="35">
            Some Default Value
        </text>
    </svg>
</Resource>
```

Parameters

The resource component allows resources to be configured as template literals or functions. Parameters can then be supplied via the params prop.

```
import Configuration from 'configuration';
import Resource from 'react-resource';

// Load Resources Into Global Configuration
Configuration.global.load( {
    'resource.someText': 'Test ${ someValue }',
    'resource.someImage': ( props ) =>
        <svg>
            <text x="0" y="35" fontFamily="Verdana" fontSize="35">
                Test { props.someValue }
            </text>
        </svg>
} );

// Render some text setup in configuration
<Resource name='resource.someText' params={ someValue: "123" } />

// Render some image setup in configuration
<Resource name='resource.someImage' params={ someValue: "123" } />
```
npm package: @jkempema/replace-state
Description: function that replaces a section of state
Latest version: 1.0.3

# replace-state

function that allows replacing sections of an object graph

## Usage

Replace using a path of properties

```
import replaceState from 'replace-state';

const state = {
    p1: {
        p2: 'some-value'
    }
};

const newState = replaceState( state, 'p1.p2', 'new-value' );
```

Replace using an array of properties

```
import replaceState from 'replace-state';

const state = {
    p1: {
        p2: 'some-value'
    }
};

const newState = replaceState( state, [ 'p1', 'p2' ], 'new-value' );
```

Replace when the value is an array

```
import replaceState from 'replace-state';

const state = {
    p1: {
        p2: [ {
            id: 1,
            value: 'some-value'
        }, {
            id: 2,
            value: 'some-other-value'
        } ]
    }
};

const newState = replaceState( state, [ 'p1', ( item ) => item.id === 1 ],  'new-value' );
```

Replace with a function

```
import replaceState from 'replace-state';

const state = {
    p1: {
        p2: 'some-value'
    }
};

const newState = replaceState( state, 'p1.p2', ( p2 ) => 'new-value' );
```
npm package: @jkemperman/capacitor-firebase-dynamic-links
Description: Firebase dynamic links Plugin for Capacitoritor
Author: Sencrop
Latest version: 0.0.11

# @sencrop/capacitor-firebase-dynamic-links

Firebase dynamic links Plugin for Capacitoritor

## Install

```bash
npm install @sencrop/capacitor-firebase-dynamic-links
npx cap sync
```

## API

<docgen-index>

* [`addListener('deepLinkOpen', ...)`](#addlistenerdeeplinkopen-)
* [Interfaces](#interfaces)

</docgen-index>

<docgen-api>
<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->

### addListener('deepLinkOpen', ...)

```typescript
addListener(eventName: 'deepLinkOpen', listenerFunc: (data: DeepLinkOpen) => void) => PluginListenerHandle
```

| Param              | Type                                                                     |
| ------------------ | ------------------------------------------------------------------------ |
| **`eventName`**    | <code>'deepLinkOpen'</code>                                              |
| **`listenerFunc`** | <code>(data: <a href="#deeplinkopen">DeepLinkOpen</a>) =&gt; void</code> |

**Returns:** <code><a href="#pluginlistenerhandle">PluginListenerHandle</a></code>

--------------------


### Interfaces


#### PluginListenerHandle

| Prop         | Type                                      |
| ------------ | ----------------------------------------- |
| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |


#### DeepLinkOpen

| Prop      | Type                |
| --------- | ------------------- |
| **`url`** | <code>string</code> |

</docgen-api>
npm package: @jkershaw/harbour
Description: Zero-dependency local service discovery dashboard
Latest version: 0.1.0

# Harbour

Zero-dependency local service discovery dashboard. One command shows every service running on your machine.

![Harbour dashboard](https://harbour.cat/screenshots/dashboard.png)

## Install

```bash
npx @jkershaw/harbour
```

Or install globally:

```bash
npm i -g @jkershaw/harbour
harbour
```

## What it does

Harbour scans your machine for listening services and displays them in a visual grid. It auto-detects project names, tech stacks, and favicons — no configuration needed.

- Discovers local services by scanning listening ports
- Identifies frameworks (Next.js, Vite, Django, Rails, Go, Rust, ...)
- Shows project names from package.json, README, pyproject.toml, Cargo.toml, go.mod
- Fetches favicons from running services
- Pin, hide, and bookmark services
- Light and dark themes

## Configuration

| Option | Default | Example |
|---|---|---|
| Port (arg) | `2999` | `harbour 3000` |
| Port (env) | `2999` | `PORT=3000 harbour` |
| Data directory | `./data` | `HARBOUR_DATA_DIR=~/.harbour harbour` |

## Requirements

Node.js >= 22

## Links

- Website: [harbour.cat](https://harbour.cat)
- Source: [github.com/JKershaw/harbour](https://github.com/JKershaw/harbour)

## License

MIT