open-index/open-npm huggingface dataset:
npm package: @rolldown/node-binding-linux-arm-gnueabihf
Description: Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API. 
Latest version: 0.0.5

# `@rolldown/node-binding-linux-arm-gnueabihf`

This is the **armv7-unknown-linux-gnueabihf** binary for `@rolldown/node-binding`
npm package: @rolldown/plugin-jsx-remove-attributes
Description: Rolldown plugin to remove JSX attributes (e.g. data-testid)
Latest version: 0.1.1

# @rolldown/plugin-jsx-remove-attributes [![npm](https://img.shields.io/npm/v/@rolldown/plugin-jsx-remove-attributes.svg)](https://npmx.dev/package/@rolldown/plugin-jsx-remove-attributes)

Rolldown plugin to remove JSX attributes (e.g. `data-testid`).

This plugin is similar to [`babel-plugin-react-remove-properties`](https://github.com/oliviertassinari/babel-plugin-react-remove-properties) but uses Rolldown's native AST parser and [native magic string API](https://rolldown.rs/in-depth/native-magic-string) instead of Babel, making it faster and requiring no additional dependencies.

## Install

```bash
pnpm add -D @rolldown/plugin-jsx-remove-attributes
```

## Usage

```js
import jsxRemoveAttributes from '@rolldown/plugin-jsx-remove-attributes'

export default {
  plugins: [
    jsxRemoveAttributes({
      // options
    }),
  ],
}
```

### Example

**In**

```jsx
export default function Home() {
  return (
    <div data-test-id="1" data-custom="1a">
      <div data-custom="2">
        <h1 data-testid="3">Hello World!</h1>
      </div>
    </div>
  )
}
```

**Out** (with default options)

```jsx
export default function Home() {
  return (
    <div data-custom="1a">
      <div data-custom="2">
        <h1>Hello World!</h1>
      </div>
    </div>
  )
}
```

Attributes matching `/^data-test/` (`data-test-id` and `data-testid`) are removed, while `data-custom` is preserved.

## Options

### `attributes`

- **Type:** `Array<string | RegExp>`
- **Default:** `[/^data-test/]`

Patterns to match JSX attribute names to remove. Strings are exact matches.

```js
jsxRemoveAttributes({
  attributes: [/^data-test/, 'data-custom'],
})
```

## Benchmark

Results of the benchmark that can be run by `pnpm bench` in `./benchmark` directory:

```
  name                                         hz      min     max     mean      p75     p99    p995    p999     rme  samples
· @rolldown/plugin-jsx-remove-attributes  12.9805  72.0620  107.49  77.0388  74.7614  107.49  107.49  107.49  ±9.99%       10
· @rolldown/plugin-babel                   5.1662   183.08  223.91   193.56   197.79  223.91  223.91  223.91  ±5.22%       10
· @rollup/plugin-swc                      11.3756  82.0540  111.68  87.9076  87.6005  111.68  111.68  111.68  ±6.98%       10

@rolldown/plugin-jsx-remove-attributes - bench/jsx-remove-attributes.bench.ts > JSX Remove Attributes Benchmark
  1.14x faster than @rollup/plugin-swc
  2.51x faster than @rolldown/plugin-babel
```

The benchmark was ran on the following environment:

```
OS: macOS Tahoe 26.3
CPU: Apple M4
Memory: LPDDR5X-7500 32GB
```

## License

MIT

## Credits

The implementation is based on [swc-project/plugins/packages/react-remove-properties](https://github.com/swc-project/plugins/tree/main/packages/react-remove-properties) ([Apache License 2.0](https://github.com/swc-project/plugins/blob/main/LICENSE)). Test cases are also adapted from it.
npm package: @rolldown/plugin-node-polyfills
Description: node polyfills for Rolldown
Author: Evan You
Latest version: 1.0.3

# @rolldown/plugin-node-polyfills

This is a node polyfills plugin for [Rolldown](https://rolldown.rs/), largely based on the original [rollup-plugin-polyfill-node](https://github.com/FredKSchott/rollup-plugin-polyfill-node) by @fks, which is in turn a fork of [rollup-plugin-node-polyfills](https://github.com/ionic-team/rollup-plugin-node-polyfills).

The reason for a Rolldown-specific version is because Rolldown natively supports [esbuild-style `inject` option](https://esbuild.github.io/api/#inject), which removes the need for [@rollup/plugin-inject](https://github.com/rollup/plugins/tree/master/packages/inject#readme), which is used to inject polyfills for globals like `Buffer`. Rolldown's native `inject` is many times more efficient than a plugin because it completely avoids extra AST parse and traversals.

## Quickstart

```
npm install --save-dev @rolldown/plugin-node-polyfills
```

```js
import { rolldown } from "rolldown";
import nodePolyfills from "@rolldown/plugin-node-polyfills";

rolldown({
  entry: "main.js",
  plugins: [nodePolyfills()],
});
```

## Node.js Builtin Support Table

The following modules include ES6 specific version which allow you to do named imports in addition to the default import and should work fine if you only use this plugin.

- process\*
- events
- stream\*
- util\*
- path
- buffer\*
- querystring
- url\*
- string_decoder\*
- punycode
- http\*†
- https\*†
- os\*
- assert\*
- constants
- timers\*
- console\*‡
- vm\*§
- zlib\*
- tty
- domain
- dns∆
- dgram∆
- child_process∆
- cluster∆
- module∆
- net∆
- readline∆
- repl∆
- tls∆
- fs˚
- crypto˚
- perf*hooks˚ - \*\_New:* just an empty shim for now, but would love help building a true polyfill!\*

† the http and https modules are actually the same and don't differentiate based on protocol

‡ default export only, because it's console, seriously just use the global

§ vm does not have all corner cases and has less of them in a web worker

∆ not shimmed, just returns mock

˚ shimmed, but too complex to polyfill fully. Avoid if at all possible. Some bugs and partial support expected.

Not all included modules bundle equally, streams (and by extension anything that requires it like http) are a mess of circular references that are pretty much impossible to tree-shake out, similarly url methods are actually a shortcut to a url object so those methods don't tree shake out very well, punycode, path, querystring, events, util, and process tree shake very well especially if you do named imports.
npm package: @rolldown/plugin-styled-jsx
Description: Rolldown plugin for styled-jsx CSS scoping
Latest version: 0.1.1

# @rolldown/plugin-styled-jsx [![npm](https://img.shields.io/npm/v/@rolldown/plugin-styled-jsx.svg)](https://npmx.dev/package/@rolldown/plugin-styled-jsx)

Rolldown plugin for [styled-jsx](https://github.com/vercel/styled-jsx) CSS scoping.

This plugin utilizes Rolldown's [native magic string API](https://rolldown.rs/in-depth/native-magic-string) instead of Babel and is more performant than using [`styled-jsx/babel`](https://github.com/vercel/styled-jsx#getting-started) with [`@rolldown/plugin-babel`](https://npmx.dev/package/@rolldown/plugin-babel).

## Install

```bash
pnpm add -D @rolldown/plugin-styled-jsx
```

## Usage

```js
import styledJsx from '@rolldown/plugin-styled-jsx'

export default {
  plugins: [
    styledJsx({
      // options
    }),
  ],
}
```

## Options

### `browsers`

- **Type:** [`Targets`](https://lightningcss.dev/transpilation.html#browser-targets) (from `lightningcss`)
- **Default:** `undefined`

Target browser versions for CSS transpilation. See the [lightningcss documentation](https://lightningcss.dev/transpilation.html#browser-targets) for details.

```js
styledJsx({
  browsers: {
    chrome: 95 << 16,
    firefox: 90 << 16,
  },
})
```

### `sourceMap`

- **Type:** `boolean`
- **Default:** `true` in development, `false` otherwise

Generates inline source maps for scoped CSS, allowing browser DevTools to map styles back to where they are defined in the source file.

```js
styledJsx({
  sourceMap: true,
})
```

## Benchmark

Results of the benchmark that can be run by `pnpm bench` in `./benchmark` directory:

```
  name                              hz      min      max     mean      p75      p99     p995     p999     rme  samples
· @rolldown/plugin-styled-jsx  10.9402  89.9217  96.5430  91.4056  91.2763  96.5430  96.5430  96.5430  ±1.49%       10
· @rolldown/plugin-babel        4.3779   223.52   238.96   228.42   230.16   238.96   238.96   238.96  ±1.65%       10
· @rollup/plugin-swc            9.4885   103.62   109.31   105.39   105.83   109.31   109.31   109.31  ±1.11%       10

@rolldown/plugin-styled-jsx - bench/styled-jsx.bench.ts > Styled JSX Benchmark
  1.15x faster than @rollup/plugin-swc
  2.50x faster than @rolldown/plugin-babel
```

The benchmark was ran on the following environment:

```
OS: macOS Tahoe 26.3
CPU: Apple M4
Memory: LPDDR5X-7500 32GB
```

## License

MIT

## Credits

The implementation is based on [swc-project/plugins/packages/styled-jsx](https://github.com/swc-project/plugins/tree/main/packages/styled-jsx) ([Apache License 2.0](https://github.com/swc-project/plugins/blob/main/LICENSE)). Test cases are also adapted from it.
npm package: @rolldown/pluginutils
Description: A utility library for building flexible, composable filter expressions that can be used in plugin hook filters of Rolldown/Vite/Rollup/Unplugin plugins.
Latest version: 1.0.0-rc.15

# @rolldown/pluginutils

A utility library for building flexible, composable filter expressions that can be used in plugin hook filters of Rolldown/Vite/Rollup/Unplugin plugins.

## Installation

```sh
pnpm add @rolldown/pluginutils
```

## Usage

### Simple Filters

```ts
import { exactRegex, makeIdFiltersToMatchWithQuery, prefixRegex } from '@rolldown/pluginutils';

// Match exactly 'foo.js'
const filter = exactRegex('foo.js');

// Match any id starting with 'lib/'
const prefix = prefixRegex('lib/');

// Match ids with query params (e.g. 'foo.js?bar')
const idFilters = makeIdFiltersToMatchWithQuery(['**/*.js', /\.ts$/]);

// Usage in a plugin to define a hook filter
const myPlugin = {
  resolveId: {
    filter: {
      id: [exactRegex('MY_ID_TO_CHECK'), /some-other-regex/],
    },
    handler(id) {
      // Your code here
    },
  },
};
```

### Composable Filters

> [!WARNING]
> Composable filters are not yet supported in Vite or unplugin. They can be used in Rolldown plugins only.

```ts
import { and, id, include, moduleType, query } from '@rolldown/pluginutils';

// Build a filter expression
const filterExpr = and(id(/\.ts$/), moduleType('ts'), query('foo', true));

// Usage in a plugin to define a hook filter
const myPlugin = {
  transform: {
    filter: [include(filterExpr)],
    handler(code, id, options) {
      // Your code here
    },
  },
};
```

## API Reference

### Simple Filters

- `exactRegex(str: string, flags?: string): RegExp` — Matches the exact string.
- `prefixRegex(str: string, flags?: string): RegExp` — Matches values with the given prefix.
- `makeIdFiltersToMatchWithQuery(input: string | RegExp | (string | RegExp)[]): string | RegExp | (string | RegExp)[]` — Adapts filters to match ids with query params.

### Composable Filters

- `and(...exprs)` / `or(...exprs)` / `not(expr)` — Logical composition of filter expressions.
- `id(pattern, params?)` — Filter by id. A `string` pattern is matched by exact equality (not glob); a `RegExp` is tested against the id.
- `importerId(pattern, params?)` — Filter by importer id. A `string` pattern is matched by exact equality; a `RegExp` is tested against the importer id. Only usable with the `resolveId` hook.
- `moduleType(type)` — Filter by module type (e.g. 'js', 'tsx', or 'json').
- `code(pattern)` — Filter by code content.
- `query(key, pattern)` — Filter by query parameter.
- `include(expr)` / `exclude(expr)` — Top-level include/exclude wrappers.
- `queries(obj)` — Compose multiple query filters.

### Utilities

- `filterVitePlugins(plugins)` — Filters out Vite plugins with `apply: 'serve'`.
npm package: @rolled-potatoes/opencode-mermaid
Description: OpenCode plugin — render Mermaid diagrams in the browser
Latest version: 0.2.0

# @rolled-potatoes/opencode-mermaid

An [OpenCode](https://opencode.ai) plugin that renders Mermaid diagrams in your browser.

Whenever the AI writes a `mermaid` code block, it automatically calls `render_mermaid` to open the diagram in your default browser. Multiple diagrams within the same session are accumulated in a single HTML file.

## Install

Add the package name to the `plugin` array in your `opencode.json`:

```json
{
  "plugin": ["@rolled-potatoes/opencode-mermaid"]
}
```

OpenCode will install it automatically on next start.

## Features

- Opens diagrams in the browser via a local HTML file (`/tmp/mermaid-<sessionID>.html`)
- Accumulates all diagrams from a session in one file — just refresh the tab
- Collapsible source view for each diagram
- Cross-platform: macOS (`open`), Linux (`xdg-open`), Windows (`start`)
- Uses [Mermaid.js v11](https://mermaid.js.org) via CDN — no build step needed

## Supported diagram types

flowchart, sequence, class, pie, gantt, state, ER, mindmap, timeline, git graph, and anything else Mermaid supports.

## License

MIT
npm package: @rollerz/framework
Description: Rollerz Framework for building games and applications
Author: Rollerz
Latest version: 0.1.0

# @rollerz/framework

The Rollerz Framework for building games and applications on the Rollerz platform.

## Installation

```bash
npm install @rollerz/framework @rollerz/types
# or
yarn add @rollerz/framework @rollerz/types
# or
pnpm add @rollerz/framework @rollerz/types
```

## Quick Start

```typescript
import { RollerzFramework } from '@rollerz/framework';

// Initialize the framework
const framework = new RollerzFramework({
  // Your configuration
});

// Start building your game
framework.init();
```

## Features

- 🎮 Game development utilities
- 🔧 Easy configuration
- 📱 Cross-platform support
- 🚀 High performance

## Documentation

For complete documentation and examples, visit: [Rollerz SDK Documentation](https://your-docs-url.com)

## License

MIT
npm package: @rollerz/sdk
Description: TypeScript definitions for Rollerz SDK - provides IDE autocomplete and IntelliSense support
Author: Rollerz
Latest version: 0.1.0

# @rollerz/sdk

TypeScript definitions for Rollerz SDK that provide IDE autocomplete and IntelliSense support when using the global RollerzSDK.

## Installation (for IDE support only)

Install as a **dev dependency** to get autocomplete in your IDE:

```bash
npm install --save-dev @rollerz/sdk
# or
yarn add --dev @rollerz/sdk
# or
pnpm add --save-dev @rollerz/sdk
```

## Usage

This package provides TypeScript definitions for the global `RollerzSDK` object. You don't need to import anything - just install the package and get instant autocomplete!

### HTML Setup
```html
<!-- Include the Rollerz SDK script -->
<script src="https://cdn.rollerz.com/sdk.global.js"></script>

<!-- Your game script -->
<script>
  // RollerzSDK is now available globally with full autocomplete!
  RollerzSDK.init({
    // Your IDE will show all available options here
  });
</script>
```

### TypeScript/JavaScript Files
```typescript
// No imports needed! Just use RollerzSDK with full autocomplete
RollerzSDK.createGame({
  // Full IntelliSense support
  name: "My Game",
  // IDE shows all available properties
});

// Access providers with autocomplete
RollerzSDK.providers.go3.authenticate();
```

## Features

- 💡 **Zero-import autocomplete** - No imports needed, just install and use
- 🔧 **Full IDE IntelliSense** - Complete method and property suggestions
- 🎯 **Type safety** - Catch errors before runtime
- 📝 **JSDoc support** - Detailed documentation in tooltips
- 🚀 **Lightweight** - Only TypeScript definitions, no runtime code
- 🛠️ **Dev-only dependency** - Doesn't affect your bundle size

## How It Works

1. **Install as dev dependency** - Only affects development, not production
2. **Global types are automatically available** - No configuration needed
3. **Use RollerzSDK anywhere** - Full autocomplete in any .js/.ts file
4. **Works with any setup** - Vanilla JS, React, Vue, Angular, etc.

## IDE Support

Works with all major IDEs and editors:
- ✅ **VS Code** - Full IntelliSense and autocomplete
- ✅ **WebStorm/IntelliJ** - Complete type information
- ✅ **Sublime Text** - With TypeScript plugin
- ✅ **Vim/Neovim** - With LSP support
- ✅ **Any TypeScript-aware editor**

## Documentation

For complete documentation, examples, and API reference, visit: [Rollerz SDK Documentation](https://github.com/RoomOneUS/RollerzSDK)

## Dependencies

- `@rollerz/types` - Core type definitions
- `uuid` - Unique identifier generation

## License

MIT
npm package: @rollerz/types
Description: TypeScript type definitions for Rollerz SDK
Author: Rollerz
Latest version: 0.1.0

# @rollerz/types

TypeScript type definitions for the Rollerz SDK platform.

## Installation

```bash
npm install @rollerz/types
# or
yarn add @rollerz/types
# or
pnpm add @rollerz/types
```

## Usage

```typescript
import { GameConfig, PlayerData, GameState } from '@rollerz/types';

// Use the types in your game development
const gameConfig: GameConfig = {
  // Your game configuration
};
```

## Documentation

For complete documentation, visit: [Rollerz SDK Documentation](https://your-docs-url.com)

## License

MIT
npm package: @rollingbytes/regexex
Description: Regex extension
Latest version: 0.1.0
Deprecated: Alpha version. Unfinished documentation.

# regexex

[![Build Status](https://travis-ci.org/{{github-user-name}}/{{github-app-name}}.svg?branch=master)](https://travis-ci.org/{{github-user-name}}/{{github-app-name}}.svg?branch=master)

[![Coverage Status](https://coveralls.io/repos/github/{{github-user-name}}/{{github-app-name}}/badge.svg?branch=master)](https://coveralls.io/github/{{github-user-name}}/{{github-app-name}}?branch=master)

[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)

# Using this module in other modules

Here is a quick example of how this module can be used in other modules. The [TypeScript Module Resolution Logic](https://www.typescriptlang.org/docs/handbook/module-resolution.html) makes it quite easy. The file `src/index.ts` is a [barrel](https://basarat.gitbooks.io/typescript/content/docs/tips/barrel.html) that re-exports selected exports from other files. The _package.json_ file contains `main` attribute that points to the generated `lib/index.js` file and `typings` attribute that points to the generated `lib/index.d.ts` file.

> If you are planning to have code in multiple files (which is quite natural for a NodeJS module) that users can import, make sure you update `src/index.ts` file appropriately.

Now assuming you have published this amazing module to _npm_ with the name `my-amazing-lib`, and installed it in the module in which you need it -

- To use the `Greeter` class in a TypeScript file -

```ts
import { Greeter } from "my-amazing-lib";

const greeter = new Greeter("World!");
greeter.greet();
```

- To use the `Greeter` class in a JavaScript file -

```js
const Greeter = require('my-amazing-lib').Greeter;

const greeter = new Greeter('World!');
greeter.greet();
```

## Setting travis and coveralls badges
1. Sign in to [travis](https://travis-ci.org/) and activate the build for your project.
2. Sign in to [coveralls](https://coveralls.io/) and activate the build for your project.
3. Replace {{github-user-name}}/{{github-app-name}} with your repo details like: "ospatil/generator-node-typescript".
npm package: @rollinginfra/abort-controller
Description: An approximate copy of the built in `AbortController` on the frontend. This should be good enough for most use cases that require an AbortController/AbortSignal pair.
Latest version: 1.0.0

# Abort Controller

An approximate copy of the built in `AbortController` on the frontend. This should be good enough for most use cases that require an AbortController/AbortSignal pair.
npm package: @rollinginfra/secret-encryption-fake
Description: Implements the `ISecretEncryption` interface for encrypting secrets, but **does no real encryption**.
Latest version: 1.0.0

# Secret Encryption - Fake

Implements the `ISecretEncryption` interface for encrypting secrets, but **does no real encryption**.

This package only base64 encodes secrets. It should never be used to encrypt genuine secrets.

## Usage

```ts
import SecretEncryptionFake from '@rollinginfra/secret-encryption-fake';

const encryption = new SecretEncryptionFake();
```
npm package: @rollinginfra/secret-encryption-google-kms
Description: Encrypt and decrypt secret strings using the Google KMS service.
Latest version: 1.0.0

# Secret Encryption - Google KMS

Encrypt and decrypt secret strings using the Google KMS service.

## Set Up Google KMS

1. Open [Google KMS in the Google Cloud Console](https://console.cloud.google.com/marketplace/product/google/cloudkms.googleapis.com)
1. Enable the API (if not already enabled) by clicking "Enable API"
1. Go to ["Security" -> "Key Management" in the Google Cloud Console](https://console.cloud.google.com/security/kms/keyrings)
1. Create a key ring, noting down the key ring name and key ring location for later.
1. Create a key in your new key ring, noting down the key name for later. The "Purpose" must be set to "Symmetric encrypt/decrypt". All other settings can have any value.
1. (Optional) Use "+ Add Member" on the permissions tab to give the "Cloud KMS CryptoKey Encrypter/Decrypter" role to anyone account that needs to use this secret store.

## Set up your local environment

You can set up your local environment by running `gcloud init` and following the prompts to authenticate.

```ts
import SecretEncryptionGoogleKms from '@rollinginfra/secret-encryption-google-kms';

const encryption = new SecretEncryptionGoogleKms({
  googleProjectID: `YOUR_GOOGLE_PROJECT_NAME`,
  keyRingName: `YOUR_KEY_RING_NAME`,
  keyName: `YOUR_KEY_NAME`,
  location: `YOUR_KEY_RING_LOCATION`,
});
```
npm package: @rollinginfra/secret-store-encrypted
Description: Combine an `IStateStore` and an `ISecretEncryption` to securely store encrypted secrets in a standard object store.
Latest version: 1.0.0

# Secret Store - Encrypted

Combine an `IStateStore` and an `ISecretEncryption` to securely store encrypted secrets in a standard object store.

## Usage

```ts
import SecretEncryptionGoogleKms from '@rollinginfra/secret-encryption-google-kms';
import SecretStoreEncrypted from '@rollinginfra/secret-store-encrypted';
import StateStoreLocalFileSystem from '@rollinginfra/state-store-local-file-system';

const secrets = new SecretStoreEncrypted({
  store: new StateStoreLocalFileSystem({
    filename: `secrets.json`,
  }),
  encryption: new SecretEncryptionGoogleKms({
    googleProjectID: `YOUR_GOOGLE_PROJECT_NAME`,
    keyRingName: `YOUR_KEY_RING_NAME`,
    keyName: `YOUR_KEY_NAME`,
    location: `YOUR_KEY_RING_LOCATION`,
  }),
});
```
npm package: @rollinginfra/state-store-google-firestore
Description: Store JSON state objects in Google Firestore. Keys can be any valid UTF-8 string.
Latest version: 1.0.0

# State Store - Google Firestore

Store JSON state objects in Google Firestore. Keys can be any valid UTF-8 string.

## Set Up Google Firestore

1. [Enable the Firestore API](https://console.cloud.google.com/flows/enableapi?apiid=firestore.googleapis.com)
2. [Create a Firestore database instance](https://console.cloud.google.com/firestore/data) **N.B.** You must select the "Native mode" if prompted to choose a mode. The Datastore mode is for legacy support, and will not work with this package.
3. Choose a collection name. You don't actually need to create it as collections are automatically created when documents are added to them.

## Set up your local environment

You can set up your local environment by running `gcloud init` and following the prompts to authenticate.

```ts
import StateStoreGoogleFirestore from '@rollinginfra/state-store-google-firestore';

const state = new StateStoreGoogleFirestore({
  googleProjectID: `YOUR_GOOGLE_PROJECT_NAME`,
  collectionName: `YOUR_COLLECTION_NAME`,
});
```
npm package: @rollinginfra/state-store-google-objects
Description: Store JSON state objects in Google Objects. Keys can be any valid UTF-8 string.
Latest version: 1.0.0

# State Store - Google Objects

Store JSON state objects in Google Objects. Keys can be any valid UTF-8 string.

N.B. Google Objects do not offer transactional safety. Although Google Objects may be simpler to set up, your state may be safer to store in the Google Firestore storage

## Set Up Google Google Cloud Storage Objects

1. Enable the Cloud Storage API
2. [Create a bucket](https://console.cloud.google.com/storage/browser) **N.B.** Bucket names must be globally unique, not just unique within a project.

## Set up your local environment

You can set up your local environment by running `gcloud init` and following the prompts to authenticate.

```ts
import StateStoreGoogleObjects from '@rollinginfra/state-store-google-objects';

const state = new StateStoreGoogleObjects({
  googleProjectID: `YOUR_GOOGLE_PROJECT_NAME`,
  bucketName: `YOUR_BUCKET_NAME`,
});
```
npm package: @rollinginfra/state-store-local-file-system
Description: Store JSON state objects in a file. Keys can be any valid UTF-8 string.
Latest version: 1.0.0

# State Store - Local File System

Store JSON state objects in a file. Keys can be any valid UTF-8 string.

## Usage

```ts
import StateStoreLocalFileSystem from '@rollinginfra/state-store-local-file-system';

const state = new StateStoreLocalFileSystem({
  filename: `state.json`,
});
```
npm package: @rollinginfra/state-store-namespace
Description: Split one physical store into multiple logical store by specifying prefixes for stores.
Latest version: 1.0.0

# State Store - Namespace

Split one physical store into multiple logical store by specifying prefixes for stores.

## Usage

```ts
import StateStoreGoogleObjects from '@rollinginfra/state-store-google-objects';
import StateStoreNamespace from '@rollinginfra/state-store-local-file-system';

const state = new StateStoreGoogleObjects({
  googleProjectID: `YOUR_GOOGLE_PROJECT_NAME`,
  bucketName: `YOUR_BUCKET_NAME`,
});

const resourcesState = new StateStoreNamespace({
  prefix: `resources/`,
  state,
});
const secretsState = new StateStoreNamespace({
  prefix: `secrets/`,
  state,
});
```
npm package: @rollingversions/git-objects
Description: Core types and helpers for managing git objects.
Latest version: 2.0.1

# @rollingversions/git-objects

Core types and helpers for managing git objects.

## Helpers

### sha1

```ts
function sha1(buffer: Uint8Array): string;
```

Generate a sha1 hash from a Uint8Array

### encodeObject

```ts
function encodeObject(object: GitObject): Uint8Array;
```

Convert a `GitObject` into an un-compressed `Uint8Array`

### decodeObject

```ts
function objectIsBlob(buffer: Uint8Array): buffer is BinaryObject<Type.blob>;
function objectIsCommit(
  buffer: Uint8Array,
): buffer is BinaryObject<Type.commit>;
function objectIsTag(buffer: Uint8Array): buffer is BinaryObject<Type.tag>;
function objectIsTree(buffer: Uint8Array): buffer is BinaryObject<Type.tree>;

function decodeObject(buffer: BinaryObject<Type.blob>): BlobObject;
function decodeObject(buffer: BinaryObject<Type.commit>): CommitObject;
function decodeObject(buffer: BinaryObject<Type.tag>): TagObject;
function decodeObject(buffer: BinaryObject<Type.tree>): TreeObject;
function decodeObject(buffer: Uint8Array): GitObject;
```

Convert an un-compressed `Uint8Array` into a `GitObject`

## Types

### Type

```ts
export enum Type {
  unknown = 'unknown',
  commit = 'commit',
  tree = 'tree',
  blob = 'blob',
  tag = 'tag',
}
```

The type of a git object
npm package: @rollingversions/git-protocol
Description: Low level streaming parsers & serializers for [git protocol-v2](https://git-scm.com/docs/protocol-v2) and [git pack-protocol](https://git-scm.com/docs/pack-protocol) (see also: [protocol-common](https://git-scm.com/docs/protocol-common)).
Latest version: 2.1.0

# @rollingversions/git-protocol

Low level streaming parsers & serializers for [git protocol-v2](https://git-scm.com/docs/protocol-v2) and [git pack-protocol](https://git-scm.com/docs/pack-protocol) (see also: [protocol-common](https://git-scm.com/docs/protocol-common)).

Git terminology can be confusing. I have attempted to match the git internal names where possible, so it's easier to compare with the relevant part of the git docs. The most important thing to note is that everything is from the perspective of the server, not the client, so an "upload request" is a request sent from the client to the server that asks the server to "upload" data to the client. This is what is sent by "fetch" or "pull" commands

## API

### Capabilities

`Capabilities` are used to communicate the capabilities supported by either the server or the client. They are represented as a `Map<string, string | boolean>`.

### parseInitialResponse

```ts
function parseInitialResponse(
  response: AsyncIterableIterator<Uint8Array>,
): Promise<Capabilities>;
```

Parse the response to calling `GET https://example.com/example-repo.git/info/refs?service=git-upload-pack`
npm package: @rollingversions/git-streams
Description: Helpers for dealing with various forms of binary & object streams, using `AsyncIterator` as the canonical format.
Latest version: 1.0.0

# @rollingversions/git-streams

Helpers for dealing with various forms of binary & object streams, using `AsyncIterator` as the canonical format.

## streamToAsyncIterator

```ts
function streamToAsyncIterator(
  readable: NodeJS.ReadableStream | ReadableStream<Uint8Array>,
): AsyncIterableIterator<Uint8Array>;
```

Convert a binary `NodeJS.ReadableStream` or a browser `ReadableStream<Uint8Array>` into an `AsyncIterableIterator<Uint8Array>`

## asyncIteratorToNodeStream

```ts
function asyncIteratorToNodeStream(
  iterator: AsyncIterableIterator<Uint8Array>,
  options?: {
    highWaterMarkBytes?: number;
  },
): NodeJS.ReadableStream;
```

Convert a `AsyncIterableIterator<Uint8Array>` into a binary `NodeJS.ReadableStream`

## asyncIteratorToBrowserStream

```ts
function asyncIteratorToBrowserStream(
  iterator: AsyncIterableIterator<Uint8Array>,
  options?: {highWaterMarkBytes?: number},
): ReadableStream<Uint8Array>;
```

Convert a `AsyncIterableIterator<Uint8Array>` into a binary `ReadableStream<Uint8Array>`

## asyncIteratorToStream

```ts
function asyncIteratorToStream(
  iterator: AsyncIterableIterator<Uint8Array>,
  options?: {highWaterMarkBytes?: number},
): ReadableStream<Uint8Array> | NodeJS.ReadableStream;
```

If `ReadableStream` exists (i.e. in the browser), call `asyncIteratorToBrowserStream`, otherwise call `asyncIteratorToNodeStream`.

## asyncIteratorToBuffer

```ts
function asyncIteratorToBuffer(
  iterator: AsyncIterableIterator<Uint8Array>,
): Promise<Uint8Array>;
```

Gather all the data from an `AsyncIterableIterator<Uint8Array>` into a single concatenated `Uint8Array`.

## asyncIteratorToArray

```ts
function asyncIteratorToArray<T>(
  iterator: AsyncIterableIterator<T>,
): Promise<T[]>;
```

Collect all the values in an `AsyncIterableIterator` of objects into an array.

## mergeAsyncIterator

```ts
function mergeAsyncIterator<TInput>(
  ...iterators: AsyncIterableIterator<TInput>[]
): AsyncIterableIterator<TInput>;
```

Take a list of `AsyncIterableIterator` and merge them into a single one that returns the union of all values, interleaved in whatever order they are returned.

## splitAsyncIterator

```ts
function splitAsyncIterator<TInput, TOutput extends any[]>(
  iterator: AsyncIterableIterator<TInput>,
  ...mappers: {
    [key in keyof TOutput]: (v: TInput) => undefined | TOutput[key];
  }
): {
  [key in keyof TOutput]: AsyncIterableIterator<TOutput[key]>;
};
```

Take an `AsyncIterableIterator` and split the values into multiple separate streams according to a filtering/mapping function. N.B. you must consume values from all returned `AsyncIterableIterator`s otherwise the others will stall.