open-index/open-npm huggingface dataset:
npm package: @scitlab/n8n-nodes-doccape
Description: n8n node to redact (pseudonymize or anonymize) PII in text using the Doccape API
Author: Scitlab
Latest version: 0.2.1

# n8n-nodes-doccape

This is an n8n community node. It lets you use _Doccape_ in your n8n workflows.

_Doccape_ is an anonymization and pseudonymization solution for various file formats. It is a product of [Scitlab](https://scitlab.de/).

[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

[Installation](#installation)  
[Operations](#operations)  
[Credentials](#credentials)  
[Compatibility](#compatibility)  
[Usage](#usage)  
[Resources](#resources)

## Installation

Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

## Operations

- Anonymize: Anonymize or pseudonymize an input text.

## Credentials

You need an api key to use this node. You can get one by registering at [Doccape](https://api.doccape.de).

## Compatibility

This node was developed and tested using n8n version 1.81.4. It has not been tested with other versions.

## Usage

This node anonymizes or pseudonymizes an input text. You must set the `text` attribute in the node's settings to the source of the text you want to anonymize. The node will then output the anonymized text.
Additionally, with the `usePseudonyms` configuration you can set the mode to either `anonymize` or `pseudonymize`. The default mode is `pseudonymize`.
With the `textLabels` configuration you can set the types of PII that are detected. For a list of supported types, see the [Doccape Api documentation](https://api.doccape.de/api-docs).

## Resources

- [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
- [Doccape](https://doccape.de)
npm package: @scitotec/eslint-plugin-rules
Description: A plugin providing custom ESLint rules made by Scitotec GmbH
Author: Scitotec GmbH
Latest version: 2.0.0

[![npm version](https://img.shields.io/npm/v/@scitotec/eslint-plugin-rules.svg)](https://www.npmjs.com/package/@scitotec/eslint-plugin-rules)
[![license](https://img.shields.io/npm/l/@scitotec/eslint-plugin-rules.svg)](./LICENSE)

# @scitotec/eslint-plugin-rules

A plugin providing custom ESLint rules made by [Scitotec GmbH](https://scitotec.de).


## Installation

You'll first need to install [ESLint](http://eslint.org):

```
$ npm i eslint --save-dev
```

Next, install `@scitotec/eslint-plugin-rules`:

```
$ npm install @scitotec/eslint-plugin-rules --save-dev
```

**Note:** If you installed ESLint globally (using the `-g` flag) then you must also install `@scitotec/eslint-plugin-rules` globally.

## Usage

Import `@scitotec/rules` within your `eslint.config.js` configuration file.

```javascript
import pluginScitotec from '@scitotec/eslint-plugin-rules'
```


Then just add the recommended rules to your plugin:

```javascript
export default [
    // ... your other rules...
    ...pluginScitotec.configs.recommended,
]
```

Alternatively, add the plugin and configure the rules yourself:

```javascript
export default [
    // ... your other rules...
    {
        plugins: {
            '@scitotec': pluginScitotec,
        },
        rules: {
            "@scitotec/split-imports": "warn",
        },
    },
]
```

## Supported Rules

* split-imports: Require an independent import statement per module.
npm package: @sciurus/app
Description: Provides core App functionality for Sciurus Engine
Latest version: 0.0.7

# @sciurus/app

Core application framework for the Sciurus Engine, providing application lifecycle management and plugin system.

## Architecture

The app package implements a modular application framework with three main components:

### App System

The core application system manages the game engine lifecycle:

- **App**: Main application container that coordinates the entire system
- **SubApp**: Independent sub-applications with their own worlds and plugins
- **World Integration**: Seamless integration with the ECS system

### Plugin System

Extensible plugin architecture for modular functionality:

- **Plugin**: Base interface for all plugins
- **PluginGroup**: Organizes multiple plugins into cohesive units
- **Plugin Builder**: Fluent API for configuring plugin groups and dependencies

### Schedule System

Manages the application update loop with ordered execution phases:

- **Main Schedule**: Core update loop with fixed timestep support
- **Schedule Phases**:
  - PreStartup → Startup → PostStartup (initialization)
  - First → PreUpdate → StateTransition → Update → PostUpdate → Last (main loop)
- **Fixed Update**: Time-based update system for consistent simulation

## Core Features

- **Game Engine Foundation**: Built for game development with ECS architecture
- **Plugin System**: Modular design for extensible functionality
- **Fixed Timestep**: Consistent update loop for game logic
- **Multiple Worlds**: Support for multiple independent ECS worlds
- **Resource Management**: Global state and resource handling

## License

MIT
npm package: @sciurus/ecs
Description: Sciurus Engine's entity component system
Latest version: 0.0.7

# @sciurus/ecs

A high-performance Entity Component System (ECS) for TypeScript, inspired by Bevy ECS.

## Overview

@sciurus/ecs is an archetype-based ECS implementation that follows the design principles of Rust's Bevy ECS. It provides a robust foundation for building complex, data-driven applications with excellent performance characteristics.

## Core Concepts

### World

The World is the central container that manages all ECS state:
- Entities and their components
- Resources (global state)
- Systems and their schedules
- Event dispatch and handling

### Components

Components are pure data containers that can be attached to entities. The system uses archetype-based storage for efficient component access and iteration.

### Systems

Systems are functions that operate on entities, components, and resources. They can:
- Query entities with specific component combinations
- Access and modify resources
- Handle events
- Execute in a defined order through the schedule system

### Queries

Efficient filters for accessing entities with specific component combinations. Queries support:
- Change detection
- Component filtering (With, Without, Added, Changed)
- Parallel iteration

### Resources

Global state that can be accessed by systems. Features include:
- Type-safe access
- Change detection
- Initialization on demand

## Features

- **High Performance**: Archetype-based storage for efficient component access
- **Change Detection**: Track component and resource modifications
- **Bundle System**: Group related components together
- **Event System**: Type-safe event dispatch and handling
- **Parallel Execution**: Systems can run concurrently when possible
- **Schedule System**: Fine-grained control over system execution order
- **Type Safety**: Leverages TypeScript's type system for compile-time safety

## License

MIT
npm package: @sciurus/state
Description: Finite state machines for Sciurus
Latest version: 0.0.7

# @sciurus/state

Finite state machines for the Sciurus Entity Component System framework.

## Overview

`@sciurus/state` provides a robust state management system for Sciurus applications. It enables you to define, transition between, and react to state changes in a type-safe and efficient manner. The package implements state-scoped entities and events, ensuring proper cleanup during state transitions.

## Architecture

The state package implements a comprehensive state management system with several key components:

### State System

The core state management system handles state transitions and lifecycle:

- **State**: Resource containing the current state value
- **NextState**: Resource for requesting state transitions
- **StateTransitionEvent**: Event triggered during state transitions
- **StatesPlugin**: Plugin that sets up the state transition infrastructure

### State Types

Different types of states for various use cases:

- **FreelyMutableState**: Basic states that can be changed directly
- **ComputedStates**: States that are computed based on other states
- **SubStates**: States with parent-child relationships

### State-Scoped Systems

Systems for managing entities and events tied to specific states:

- **State-Scoped Entities**: Entities that are automatically cleaned up when exiting a state
- **State-Scoped Events**: Events that are automatically cleared when exiting a state

### Schedule System

Schedules for controlling when state-related code executes:

- **StateTransition**: Main schedule for handling state transitions
- **OnEnter/OnExit**: Schedules that run when entering or exiting specific states
- **StateTransitionSteps**: Ordered steps for the state transition process

## Core Features

- **Type-Safe State Management**: Define states with full type safety using enums
- **Declarative Transitions**: Simple API for state transitions with automatic event dispatching
- **Automatic Cleanup**: State-scoped entities and events are automatically cleaned up during transitions
- **Hierarchical States**: Support for computed states and sub-states for complex state machines
- **Transition Hooks**: Run code when entering or exiting specific states
- **App Integration**: Seamless integration with the Sciurus App system

## License

MIT
npm package: @scivolemo/wolpertinger
Description: A library that fills in translations / localisations from JSON files and strings depending on the user's language preferences.
Author: Justus Bendel
Latest version: 1.0.1

# Wolpertinger
A library that fills in translations / localisations from JSON files and strings depending on the user's language preferences.

## Installation
You can add Wolpertinger to your Node project by running
`npm i @scivolemo/wolpertinger`.

## Usage
To make Wolpertinger fill in translations from your sources use it like this:
```ts
// index.ts
import {Wolpertinger, BestMatch} from "wolpertinger";

document.addEventListener("DOMContentLoaded", () => {
    const wolpertinger: Wolpertinger<BestMatch> = new Wolpertinger<BestMatch>("../translations.json", undefined, BestMatch);
    wolpertinger.loadSources(true).then(success => {wolpertinger.translateAll("Not found").then(r => {})});
});
```
This example creates a new instance wit the translation strategy "BestMatch". The translations are loaded from the file "../translations.json".
We wait for the library to finish loading the sources and then let it fill in translations for all recognized keys.

Those keys can be linked to a html element by setting the attribute `data-translation` like this:
```html
<!-- index.html -->
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Wolpertinger example</title>
    <script src="./dist/bundle.js"></script>
</head>
<body>
    <div class="Wrapper">
        <h1 data-translation="hello"></h1>
        <p data-translation="long-text"></p>
    </div>
</body>
</html>
```

The JSON file could look like this:
```json
{
  "translations": [
    {
      "key": "hello",
      "values": [
        {
          "lang": "en",
          "value": "Hello"
        },
        {
          "lang": "de",
          "value": "Hallo"
        },
        {
          "lang": "fr",
          "value": "Bonjour"
        }
      ]
    },
    {
      "key": "long-text",
      "values": [
        {
          "lang": "en",
          "value": "This text is written in English."
        },
        {
          "lang": "de",
          "value": "Dieser Text ist auf Deutsch."
        }
      ]
    }
  ]
}
```

## IndexedDB
The newest release also contains a logic to save translations that have been retrieved from a server in a local database (IndexedDB).

This functionality is still under development!

This feature is enabled by default. To disable this feature, set the option `useSavedTranslations` to `false` in the constructor like this:
```ts
new Wolpertinger<BestMatch>("../translations.json", undefined, BestMatch, useSavedTranslations=false);
```
npm package: @sckl/node-red-contrib-oparl
Description: Node-Red nodes for downloading data from an Oparl instance
Author: Marius Henkel
Latest version: 1.0.2

# OParl

Dieses Paket enthält Node-Red Nodes zur Abfrage von Daten der OParl Schnittstelle für Ratsinformationssysteme.

## Links

[Oparl](https://oparl.org/)

[Beispiel Kaiserslautern](https://ris.kaiserslautern.de/oparl/system)

[Node-Red](https://nodered.org/)

# Installation

```
npm install
npm run build
```

# Nodes

## oparl-request

Dieser Node kann Daten aus verschiedenen Kategorien einer Oparl-Instanz herunterladen und gibt diese im Output des Nodes unter `msg.payload` aus.

### Body URL

Hier muss die URL zur Oparl-Körperschaft (body), die verwendet werden soll, eingegeben werden, z. B. https://ris.kaiserslautern.de/oparl/bodies/0001/ oder https://buergerinfo.stadt-koeln.de/oparl/bodies/stadtverwaltung_koeln.

### Kategorie

Hier wird die Kategorie ausgewählt, deren Daten heruntergeladen und ausgegeben werden sollen.
npm package: @sckrz/devbox
Description: Developer Toolbox CLI - A comprehensive file and code management tool
Author: raulshma
Latest version: 0.1.7

# DevBox CLI

A comprehensive file and code management CLI tool for developers.

## Installation

```bash
# Global installation
npm install -g @sckrz/devbox

# Or use directly with npx
npx @sckrz/devbox --help

# Or with pnpx
pnpx @sckrz/devbox --help
```

## Usage

```bash
# Using the primary command
devbox --help

# Using aliases
devtoolbox --help
dtb --help

# Or via npx
npx @sckrz/devbox --help
```

## Available Commands

| Command | Alias | Description |
|---------|-------|-------------|
| `rename` | `rn` | Advanced file and folder renaming with pattern matching |
| `regex-builder` | `rb` | Interactive regex pattern builder |
| `encrypt` | `enc` | Encrypt files with AES-256-GCM encryption |
| `decrypt` | `dec` | Decrypt encrypted files |
| `fileops` | `fo` | Advanced file operations (copy, move, delete) |
| `cleanup:node` | `cn` | Clean up node_modules directories |
| `cleanup:dotnet` | `cdn` | Clean up .NET bin and obj directories |
| `discover` | `find` | Fast file discovery with pattern matching |
| `state` | `st` | Manage global application state |
| `interactive` | `i` | Launch interactive mode with guided menus |
| `sessions` | `sess` | Manage sessions and operation history |
| `audit` | `log` | Manage and view audit logs |
| `keychain` | `kc` | Manage passwords in OS keychain |
| `auth` | `authenticate` | Manage authentication and sessions |
| `theme` | `th` | Manage color themes |
| `tools` | `tool` | Manage tool registry |
| `plugin` | `pl` | Manage plugins |
| `api` | `serve` | Start the REST API server |
| `azure-blob` | `azblob` | Azure Blob Storage operations |

## Examples

```bash
# Rename files with pattern matching
devbox rename --pattern "*.txt" --prefix "backup_"

# Discover files
devbox discover "**/*.js"

# Clean up node_modules
devbox cleanup:node --dry-run

# Launch interactive mode
devbox interactive

# Manage plugins
devbox plugin list
devbox plugin install ./plugins/my-plugin
```

## Programmatic Usage

```typescript
import { ConfigManager, logger, discoverFiles } from '@sckrz/devbox';

// Use the exported utilities in your own scripts
const files = await discoverFiles('.', ['**/*.ts']);
```

## Documentation

- [Plugin System](docs/PLUGIN_SYSTEM.md) - Extend DevBox with custom plugins
- [Theme System](docs/THEME_SYSTEM.md) - Customize CLI colors and appearance
- [Interactive Mode](docs/INTERACTIVE_MODE.md) - Guided menu-driven interface
- [Help System](docs/HELP_SYSTEM.md) - Built-in help and documentation
- [Regex Builder](docs/regex-builder-feature.md) - Interactive regex pattern builder
- [Table Usage](docs/TABLE_USAGE_EXAMPLES.md) - Table formatting utilities
- [Plugin API](docs/api-plugin-manager.md) - Plugin development API reference

## Requirements

- Node.js >= 18.0.0

## License

MIT
npm package: @sclable/nestjs-async-provider
Description: ASync Provider interface for building Nestjs modules
Author: Sclable Business Solutions GmbH
Latest version: 2.0.0

# Nestjs Async Provider

Helper interface and function to create providers asynchronously for dynamic modules.

## Install

```bash
npm i @sclable/nestjs-async-provider
```

## Usage

```typescript
import { Module, Provider } from '@nestjs/common'
import { AsyncProvider, createAsyncProviders } from '@sclable/nestjs-async-provider'

@Module({})
export class SomeModule {
  public static forRoot(options: SomeModuleOptions): DynamicModule {
    const optionsProvider: Provider<SomeModuleOptions> = {
      provide: SOME_MODULE_OPTIONS,
      useValue: options,
    }

    return {
      module: SomeModule,
      imports: [...],
      providers: [..., optionsProvider],
      exports: [..., optionsProvider],
    }
  }

  public static forRoorAsync(options: AsyncProvider<SomeModuleOptions>): DynamicModule {
    const asyncProviders = createAsyncProviders(asyncOptions, SOME_MODULE_OPTIONS)

    return {
      module: SomeModule,
      providers: [..., ...asyncProviders],
      exports: [..., ...asyncProviders],
    }
  }
}
```

## API documentation

[Github Wiki](https://github.com/sclable/nestjs-libs/wiki/async-provider)
npm package: @sclable/nestjs-es-cqrs-schematics
Description: Schematics for the ES/CQRS package
Author: Sclable Business Solutions GmbH
Latest version: 2.0.7

# Schematics try-out and generator for the ES/CQRS library

## Usage

Create a JSON file with your configuration. Check the schema: `src/es-cqrs/schema.json`.

Example: new-command.json

```json
{
  "moduleName": "main",
  "verb": "do",
  "subject": "stuff again",
  "parameters": [
    {
      "name": "param1",
      "type": "string"
    },
    {
      "name": "param2",
      "type": "ImportedParameter",
      "importPath": "imported-params"
    }
  ]
}
```

Install schematics and this project:

```bash
npm i -g @angular-devkit/schematics-cli
npm i @sclable/es-cqrs-schematics
```

Run `schematics` in your code to create a command-event chain

```bash
schematics @sclable/es-cqrs-schematics:json new-command.json all
```

There are targets other than `all` but they may need a different
*JSON Schema* which can be read from the source.

Example: to only create a command, you can use the upper mentioned
JSON file with the `command` target or check `src/es-cqrs/command/command.schema.json`
and run your JSON with the `command-standalone` target.

## Additional features

### REST-API generation

Use the collection `all-rest` to create *nestjs controllers* as well. For create operation it will generate
`Post` endpoints that returns the new ID, for other modification it will `Put` endpoint with `/:id` as parameter
and returns nothing

### Graphql generation

TBD

## Examples and recommendations

### Aggregate creation

Usually there is no ID associated with a creation, only a user, so the system can assign and return a new ID.
To help with this logic this schematics can generate create component with UUID generation. It will create such
components if the `verb` is one of `[add, create, new, insert]` and the `subject` is the same as the `moduleName`

### Aggregate member generation

If needed this schematics can generate member properties for the aggregate and will set their value from the
events (otherwise handler contain just `/* no-op */` placeholder). To achieve this, set `isMember` to `true`
for the parameter that needs a member created.

### Using object parameters

If the mutation uses a single object parameter and not a list of primitive types, set `isExistingObject` to `true`.
This will generate proper value assignments.
npm package: @sclable/nestjs-graphql-scalar-uuid
Description: UUID validation for @nestjs/graphql
Author: Sclable Business Solutions GmbH
Latest version: 3.0.0

# nestjs-graphql-scalar-uuid

UUID validation for @nestjs/graphql

## Install

```shell
npm install @sclable/nestjs-graphql-scalar-uuid
```

## Usage

Add scalar to graphql file

```graphql
scalar UUIDv4
```

Add to providers

```typescript
@Module({
  ...
  providers: [UUIDv4Scalar]
})
```
npm package: @sclaflin/document-scanner
Description: Detect the largest document within an image
Author: Sean Claflin
Latest version: 0.0.1

# Document Scanner #

Scan an image for a document outline, crop it, and translate it into a rectangle.

## Usage ##

The following assumes OpenCV.js is loaded and running in your environment and "mat" is a cv.Mat instance.

```javascript
// create a DocumentScanner instance and provide the OpenCV object
const scanner = new DocumentScanner(cv);

// scan an OpenCV Mat instance for a document
// returns a Mat of the cropped and translated document
const doc = scanner.scanImage(
    // source Mat
    mat,
    // whether an outline of the document should be drawn onto the source Mat
    true
);

```

## Example ##

Included in this repository is an example implemented with NodeJS which can be run within the `/example` directory via:

```bash
node index.js
```

By default a sample document is pre-loaded and scanned.  You may upload your own images to test.  Be sure that the image you upload had good contrast between the document and the background.

## Thanks ##

* [OpenCV](https://opencv.org/) for creating an amazing toolkit.
* [PyImageSearch](https://pyimagesearch.com/2014/09/01/build-kick-ass-mobile-document-scanner-just-5-minutes/) for a well documented and helpful tutorial to get things moving in the right direction.
npm package: @sclaflin/micr-scanner
Description: OCR for MICR font
Author: Sean Claflin
Latest version: 0.0.1

# MICR (E13B) Scanner #

Magnetic Ink Character Recognition OCR for the E13B font. This module assumes a cropped image of a check will be provided. The higher the resolution & clarity, the better the results.

## A brief explanation
![MICR Reference](MICR_Reference.png)

The MICR character set includes 10 digits and 4 control characters. The four control characters are:

* transit (⑆) : bank branch delimiter
* amount (⑇): transaction amount delimiter
* on-us (⑈): customer account number delimiter
* dash (⑉): number delimiter

These characters are printed along the bottom of bank checks.

## Usage ##

The following assumes OpenCV.js is loaded and running in your environment and "mat" is a cv.Mat instance.

```javascript
// Create an MICRSCanner instance and provide the OpenCV object.
const scanner = new MICRScanner(cv);

// Scan an OpenCV Mat instance for MICR characters.
// Returns an array of strings.
const data = scanner.scanImage(mat);

// Example contents of data
// ["T011300142T","12345678U","0101"]
```

## Example ##

Included in this repository is an example implemented with NodeJS which can be run within the `/example` directory via:

```bash
node index.js
```

By default a sample check image is pre-loaded and scanned.  You may upload your own images to test.  Be sure that the image you upload is of a check image only.

## Thanks ##

* [OpenCV](https://opencv.org/) for creating an amazing toolkit.
* [PyImageSearch](https://pyimagesearch.com/2017/07/24/bank-check-ocr-with-opencv-and-python-part-i/) for a well documented and helpful tutorial to get things moving in the right direction.
npm package: @sclaxton/handlebars
Description: Experimental fork of the handlebars parser
Author: Yehuda Katz
Latest version: 0.0.2

# WARNING: THIS IS AN EXPERIMENTAL FORK OF THE HANDLEBARS PARSER ONLY, PLEASE DON'T TRY TO USE FOR ANYTHING SERIOUS

See the original repo [here](https://github.com/wycats/handlebars.js).

I've updated the [docs](https://github.com/sclaxton/handlebars.js/blob/master/docs/compiler-api.md#user-content-statements-addendum-sclaxton) to reflect the changes I've made to the parser.
npm package: @scloud/cdk-github
Description: Automates setting variables and secrets on a Github repo/environment based on output produced by the ghaUser() feature of @scloud/cdk-patterns
Author: David Carboni
Latest version: 0.2.2

# CDK Github secrets and variables

This is a companion package designed to work with `@scloud/cdk-patterns`:` https://www.npmjs.com/package/@scloud/cdk-patterns

Takes outputs produced by the `githubActions().ghaOidcRole()` and `githubActions().ghaUser()` features of `@scloud/cdk-patterns` and automates setting repo/environment secrets and variables in Github Actions.

This is intended to provide you with the environment/variable/secret handling capabilities you'll mostly need. If you have an edge-case, the repo serves as example code you can reuse to help you get what you need done more easily.

## Setup

Assuming you've called the `ghaOidcRole` or `ghaUser` function, you should have some output files under your `.infrastructure/cdk.out` directory, e.g.:

 * `.infrastructure/cdk.out/StackName.ghaSecrets.json`
 * `.infrastructure/cdk.out/StackName.ghaVariables.json`

`@scloud/cdk-github` uses these files as inputs to understand the values that need to be set on the repo (or its environments) and whether or not the value needs to be handled as a secret.

## Running

To set variables and/or secrets, you can use the following example code:

```
import { updateGithub } from '@scloud/cdk-github';

(async () => {
  await updateGithub();
})();
```

The key part is the call to the `updateGithub` function.

You can optionally pass `true` to this function if you would like this process to delete any "leftover" (orphaned) values. This removes secrets and variables if they are no longer specified by the stack. However, be aware tht this will delete any variables you've set manually! Passing `true` is recommended to fully automate and keep the set of variables and secrets clean.

You will also need the following environment variables, or pass an object with these values when you call the function:

```
export USERNAME=octocat
export PERSONAL_ACCESS_TOKEN=github_ghp_xxxxxxxxxxx
export OWNER=organization
export REPO=repository
```

or

```
{
  username: 'octocat',
  personalAccessToken: 'github_ghp_xxxxxxxxxxx',
  owner: 'organization',
  repo: 'repository',
}
```
npm package: @scloud/lambda-api
Description: Lambda handler for API Gateway proxy requests
Author: David Carboni
Latest version: 1.1.8

# Lambda API Gateway Proxy handler

A Lambda handler that routes API Gateway Proxy messages and returns an API Gateway Proxy Response.

This is a piece of useful boilerplate to handle the mechanics of routing, headers and cookies, catching any errors and handling 400, 405 and 500 errors (you can optionally handle 404 and 500 with your own handler functions).

## Releae notes

 * `1.1.8`: Trusted publishing enabled
 * `1.1.7`: Enable sending headers in ApiError
 * `1.1.4`: Simplify error console logging
 * `1.1.3`: Import from zod/v4 for backward compatibility with Zod 3
 * `1.1.2`: Fix to be able to match multiple path parameters
 * `1.1.1`: Remove functionality to lowercase the request path because this can alter path parameter values, which can be case sensitive strings
 * `1.0.5`: Add a test to verify that camel case path parameter values aren't lowercased
 * `1.0.4`: Optional schema checks using Zod
 * `0.3.8`: Optinoal generic type on `Request`
 * `0.3.7`: Fix cookie setting to use `Set-Cookie`
 * `0.3.6`: Enable parsing body as `application/x-www-form-urlencoded` as well as JSON
 * `0.3.5`: `actions/setup-node@v4` and Node `lts`
 * `0.3.4`: `ContextBuilder` no longer needs to return context values.
 * `0.3.3`: `actions/checkout@v4` and Node `20.x`
 * `0.3.2`: Add `ContextBuilder` to have the option to populate `Request.context` with access to the parsed `Request`.
 * `0.3.1`: Add path parameter parsing and a `Request.context` object to allow custom values to be passed to handter functions.
 * `0.2.4`: Allow Request.body to be `any`. Return simple text responses for handled errors (404, 500, 405).
 * `0.2.1`: Request headers are now made available in lowecase as well as their original case. The response body can now be `string` as well as `object`.
 * `0.2.2`: Add `Content-Type: text/plain` for string responses if not already set.

## Usage

Create your routes:

```
import { types } from '@scloud/lambda-api';

const routes: types.Routes = {
  '/ping': { GET: async (request: types.Request) => ({ statusCode: 200, body: {message: 'ok'} }) },
  '/path/{parameter}': { GET: async (request: types.Request) => ({ statusCode: 200, body: {message: request.pathParameters.parameter} }) },
}
```

Use `@scloud/lambda-api` in your Lambda handler:

```
import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { apiHandler, helpers } from '@scloud/lambda-api';

export async function handler(event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> {
  const result = await apiHandler(event, context, routes);
  return result;
}
```

The `apiHandler` function will call your route functions according to the method and path of the request, catching any errors and returning 404/405 if a path/method isn't defined, or 500 if an error is thrown.

## Release notes

* **0.1.24**: Decode Base-64 encoded event body if needed, before parsing as JSON
npm package: @scloud/lambda-fileupload
Description: Functions uploading/downloading files with Lambda/API Gateway where the file size is greater than the payload limit.
Author: David Carboni
Latest version: 0.0.10

# Lambda / API Gateway file uploads

There's a limit to the request size you can send to API Gateway (10M) and Lanbda (6M). This means you can't upload / download files where the size might be greater than this limit.

Even if files are smaller, you'll need to do some work to configure binary media types and base-64 encode the data. See https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings.html

If you've done some Googling, you'll likely have come across the concept of pre-signed URLs, which allow your application to upload/download directly to/from s3. This package aims to make implementing that pattern as easy as possible.

There's no magic here, these are straightforward wrapper functions that eliminate complexity and give you what you're likely to need.

This is intended to provide you with the operations you'll mostly need most of the time and, if you have an edge-case, example code you can reuse that helps you get what you need done more easily.

## Release notes

 * `0.0.10`: `actions/setup-node@v4` and Node `lts`
 * `0.0.8`: `actions/checkout@v4` and Node `20.x`
 * `0.0.7`: Fix default validity windows of `getUrl` and `putUrl` to match the documentation.

## Functions

This package offers 3 functions, `GET`/`PUT` (good for programmatic access) and `POST` (which is good for HTML forms, but a little more involved)

### GET/PUT

Most useful for programmatic assess:

```
import { getUrl, putUrl } from '@scloud/lambda-fileupload';

// Upload
const put = await putUrl('mybucket', 'key/of/destination/file.png');
const fileData = await // Read in your file
await axios.put(put, fileData);

// Download
const get = await getUrl('mybucket', 'key/of/destination/file.png');
const response = await axios.get(get);
const imageData = response.data; // Handle downloaded content

```

### POST

Most useful for HTML forms:

```
import { postUrl } 'from @scloud/lambda-fileupload'

// Form field values
const post = await postUrl('mybucket', 'key/of/destination/file.png');

console.log(post.url);
// https://mybucket.s3.eu-west-2.amazonaws.com/

console.log(post.fields);
// {
//   bucket: 'mybucket',
//   'X-Amz-Algorithm': 'AWS4-HMAC-SHA256',
//   'X-Amz-Credential': '...',
//   'X-Amz-Date': '20230813T115102Z',
//   key: 'key/of/destination/file.png',
//   Policy: '...',
//   'X-Amz-Signature': '...'
}
```

The URL goes in the form action and the fields need to be added as hidden fields in the form, with the 'file' field at the end.

For more detail on using a pre-signed post see: https://www.npmjs.com/package/@aws-sdk/s3-presigned-post#user-content-post-file-using-html-form
npm package: @scloud/lambda-local
Description: Run typical Lambda handlers locally.
Author: David Carboni
Latest version: 0.3.17

# Local Lambda runner

Allows you to run an API Gateway Proxy Lambda or an SQS Lambda locally.

## Getting started

Here are a couple of examples of running Lambda handler functions locally.

You can add a script to your `package.json` to trigger the code. Add `nodemon` as a dependency if you want to watch for changes, e.g.:

```
  "scripts": {
    "local": "nodemon src/lambda.ts --local",
    ...
  }
```

If you'd like to run on a different port, you can set a `PORT` environment variable.

### A web app example

This example runs a Lambda handler as a dynamic web app, optionally mounting a local folder to serve static content as if it were an s3 bucket:

```
// import { webappLocal } from '@scloud/lambda-local';
// import * as path from 'path';

export async function handler(event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> {
  # Lambda handler code
}

(async () => {
  if (process.argv.includes('--local')) {
    const staticPath = path.join(__dirname, '/../../static/public');
    webappLocal(handler, { sourceDirectory: staticPath, appPath: '/public' });
  }
})();
```

You can now invoke your Lambda handler function via you bowser at `localhost:3000`

### An SQS example

Add code to start a local server to the bottom of your lambda hamdler file (e.g. `src/lambda.ts`)

```
// Also available: import { apiGatewayLocal } from '@scloud/lambda-local';
import { sqsLocal } from '@scloud/lambda-local';

/**
 * Your Lambda handler function
 */
export async function handler(event: SQSEvent, context: Context): Promise<SQSBatchResponse> {
  # Lambda handler code
}

//
// This will call sqsLocal() if '--local' is specified on the command line:
//
(async () => {
  if (process.argv.includes('--local')) {
    sqsLocal(handler);
  }
})();
```

You can now invoke your Lambda handler function with e.g.:

`curl -X POST -d "SQS messgae body content" http://localhost:3000`

## Available handlers

The following havdlers are available:

 * `sqsHandler` - takes the boby of a post as the content of an SQS message to be dlievered to your handler
 * `webappLocal` - takes the method, path, headers, query string and body of a request and delivers them to your handler. You can optionally add a local direcory to be served as static content, under a specific path on your app, as if it were an s3 bucket (e.g. `/static`)
 * `webappRoutesLocal` - works the same as `webappLocal` but allows you to pass multiple cloudfront path mappings to multiple handler functions (like a microservices setup). You can optionally add a local direcory to be served as a static content fallback, as if it were an s3 bucket. In other words, if a request doesn't match a mapped path, it will fall back to static content.
 * `scheduledLocal` - for Lambdas that run in response to scheduled Cloudwatch events. An http request on any method/path will call your Lambda handler with a placeholder event.
npm package: @scloud/lambda-queue
Description: A Lambda handler that processess SQS messages.
Author: David Carboni
Latest version: 0.1.14

# Lambda SQS handler

A Lambda handler that processes SQS messages and returns any batch item failures for retry.

This is a piece of useful boilerplate to handle the mechanics of processing a batch of messages, catching any errors and retrying failed messages.

See: https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#services-sqs-batchfailurereporting

## Usage

Create your message processing function:

```
/**
 * Process a single SQS message.
 * It's safe to allow exceptions to be thrown.
 * Errors will be caught and handled as a batch item failure.
 */
export async function messageHandler(message: SQSRecord) {
  const slackWebhook = process.env.SLACK_WEBHOOK || '';
  if (slackWebhook) {
    await axios.post(slackWebhook, { text: `${message.body}` });
  } else {
    console.log(`Message would be sent to Slack: ${message.body} (process.env.SLACK_WEBHOOK isn't set)`);
  }
}
```

Call `@scloud/lambda-queue` from your Lambda handler:

```
import sqsHandler from '@scloud/lambda-queue'

export async function handler(event: SQSEvent, context: Context): Promise<SQSBatchResponse> {
  const result = await sqsHandler(messageHandler, event, context)
  return result;
}
```

The `sqsHandler` function will call your message handler for each item in the batch, catching any errors and returning an `SQSBatchResponse` with any failed message IDs so that Lambda can retry.
npm package: @scloud/s3
Description: Functions for s3 CRUD and list.
Author: David Carboni
Latest version: 1.1.0

# s3 CRUD utility functions

A collection of wrapper functions for the AWS SDKv3 that provide simplified CRUD and list operations.

This is intended to provide you with the operations you'll mostly need most of the time and, if you have an edge-case, you can use this as example code to help you get what you need done more easily.

## Changelog
 * **1.1.0**: Update `listObjects` to handle pagination if there are more than 1000 keys. The return is now just a list of keys.
 * **1.0.3**: Add batching to deleteObjects
 * **1.0.2**: Cleaner typing for return value of s3 getObject
 * **1.0.1**: Fix order of parameters in `downloadTemp` - breaking change because it switches the order of two string values
 * **0.0.13**: `actions/setup-node@v4` and Node `lts`
 * **0.0.12**: `actions/checkout@v4` and Node `20.x`
 * **0.0.11**: Add `copyObject` and remove `console.error()` output in `src/s3.ts`
 * **0.0.10**: Fix `moveObject` and shortcut return from `deleteObjects` if the object list is empty. Also make error messages unique so we can distinguish if an error is coming from `deleteObject` or `deleteObjects`. Also added generic type information to `getJson` and `putJson`.
 * **0.0.9**: Add `deleteObjects`
 * **0.0.8**: Return ETag when listing objects
 * **0.0.7**: Fix typos in documentation
 * **0.0.6**: Return object size and modification date from listObjects. This allows the caller to have more information about an object (example use-case: determine if new content to be put differs from the existing content in the same way `aws s3 sync` does - https://stackoverflow.com/a/43531938/723506).

## Functions

This package allows you to work with binary and JSON objects.

### Binary objects

 * `putObject(bucket, key, object)`: puts content to s3
 * `getObject(bucket, key)`: gets content from s3

### JSON objests

 * `putJson(bucket, key, object)`: stringifies the object and puts it to s3
 * `getJson(bucket, key)`: gets content from s3 and parses it as JSON

### List and delete

 * `deleteObject(bucket, key)`: deletes an object from s3
 * `deleteObjects(bucket, keys[])`: deletes multiple objects from s3
 * `listObjects(bucket, prefix)`: lists matching keys from the bucket
 * `objectExists(bucket, key)`: determines whether a single matching key exists in the bucket
npm package: @sclt/program-changelog
Description: Generate changelog
Latest version: 4.0.0

# Changelog

This utility generates a change log from a github milestone's PRs;

## config

Create a `.sclt-changelog.json` file like follows:

```json
{
  "$schema": "https://api.npoint.io/790efd441f0e378c0bab"
}
```

Follow the autocomplete with your IDE
npm package: @scm-manager/refractor-flatten
Description: A utility to transform Refractor ASTs to flat arrays.
Author: suin <suinyeze@gmail.com>
Latest version: 1.0.1

# @suin/refractor-flatten

A utility to transform [Refractor](https://github.com/wooorm/refractor) ASTs to flat arrays.

## Installation

```bash
yarn add @suin/refractor-flatten
# or
npm install @suin/refractor-flatten
```

## Usage

### Basic Usage

```typescript
import refractor from "refractor";
import flatten from "@suin/refractor-flatten";

const tree = refractor.highlight("`${value}`", "js");
const flat = flatten(tree);
```

The structure of `tree` is:

```
root[1]
└─0 element<span>[3]
    │ properties: {"className":["token","template-string"]}
    ├─0 element<span>[1]
    │   │ properties: {"className":["token","template-punctuation","string"]}
    │   └─0 text "`"
    ├─1 element<span>[3]
    │   │ properties: {"className":["token","interpolation"]}
    │   ├─0 element<span>[1]
    │   │   │ properties: {"className":["token","interpolation-punctuation","punctuation"]}
    │   │   └─0 text "${"
    │   ├─1 text "value"
    │   └─2 element<span>[1]
    │       │ properties: {"className":["token","interpolation-punctuation","punctuation"]}
    │       └─0 text "}"
    └─2 element<span>[1]
        │ properties: {"className":["token","template-punctuation","string"]}
        └─0 text "`"
```

The structure of the `flat` above becomes:

```
root[5]
├─0 element<span>[1]
│   │ properties: {"className":["token","template-string","template-punctuation","string"]}
│   └─0 text "`"
├─1 element<span>[1]
│   │ properties: {"className":["token","template-string","interpolation","interpolation-punctuation","punctuation"]}
│   └─0 text "${"
├─2 element<span>[1]
│   │ properties: {"className":["token","template-string","interpolation"]}
│   └─0 text "value"
├─3 element<span>[1]
│   │ properties: {"className":["token","template-string","interpolation","interpolation-punctuation","punctuation"]}
│   └─0 text "}"
└─4 element<span>[1]
    │ properties: {"className":["token","template-string","template-punctuation","string"]}
    └─0 text "`"
```

## API Reference

https://suin.github.io/refractor-flatten/
npm package: @scm-manager/remark-preset-lint
Description: Remark-lint configuration for scm-manager and its plugins
Author: SCM-Team
Latest version: 1.0.0

<p align="center">
  <a href="https://www.scm-manager.org/">
    <img alt="SCM-Manager" src="https://download.scm-manager.org/images/logo/scm-manager_logo.png" width="500" />
  </a>
</p>
<h1 align="center">
  @scm-manager/remark-preset-lint
</h1>

[Remark Lint](https://github.com/remarkjs/remark-lint) base configuration for all SCM-Manager related projects.

## Installation

Install the `@scm-manager/remark-preset-lint` as dev dependency:

```bash
yarn add --dev @scm-manager/remark-preset-lint
# or 
npm install --save-dev @scm-manager/remark-preset-lint
```

In order to use the configuration add the following snippet to your `package.json`:

```json
"remarkConfig": {
  "plugins": [
    "@scm-manager/remark-preset-lint"
  ]
},
"lint-staged": {
  "*.md": "remark-lint --"
}
```

## Need help?

Looking for more guidance? Full documentation lives on our [homepage](https://www.scm-manager.org/docs/) or the dedicated pages for our [plugins](https://www.scm-manager.org/plugins/). Do you have further ideas or need support?

- **Community Support** - Contact the SCM-Manager support team for questions about SCM-Manager, to report bugs or to request features through the official channels. [Find more about this here](https://www.scm-manager.org/support/).

- **Enterprise Support** - Do you require support with the integration of SCM-Manager into your processes, with the customization of the tool or simply a service level agreement (SLA)? **Contact our development partner Cloudogu! Their team is looking forward to discussing your individual requirements with you and will be more than happy to give you a quote.** [Request Enterprise Support](https://cloudogu.com/en/scm-manager-enterprise/).
npm package: @scm-manager/tsconfig
Description: TypeScript configuration
Author: SCM-Team
Latest version: 2.13.0

<p align="center">
  <a href="https://scm-manager.org/">
    <img alt="SCM-Manager" src="https://download.scm-manager.org/images/logo/scm-manager_logo.png" width="500" />
  </a>
</p>
<h1 align="center">
  @scm-manager/tsconfig
</h1>

TypeScript configuration for all SCM-Manager related projects.

## Installation

Install the `@scm-manager/tsconfig` as dev dependency:

```bash
yarn add --dev @scm-manager/tsconfig
# or 
npm install --save-dev @scm-manager/tsconfig
```

In order to use the config create a `tsconfig.json` in the root of the project with the following content:

```json
{
  "extends": "@scm-manager/tsconfig",
  "include": [
    "./src/main/js"
  ]
}
```

## Need help?

Looking for more guidance? Full documentation lives on our [homepage](https://scm-manager.org/docs/) or the dedicated pages for our [plugins](https://scm-manager.org/plugins/). Do you have further ideas or need support?

- **Community Support** - Contact the SCM-Manager support team for questions about SCM-Manager, to report bugs or to request features through the official channels. [Find more about this here](https://scm-manager.org/support/).

- **Enterprise Support** - Do you require support with the integration of SCM-Manager into your processes, with the customization of the tool or simply a service level agreement (SLA)? **Contact our development partner Cloudogu! Their team is looking forward to discussing your individual requirements with you and will be more than happy to give you a quote.** [Request Enterprise Support](https://cloudogu.com/en/scm-manager-enterprise/).