open-index/open-npm huggingface dataset:
npm package: @roninjin10/rollup-chains
Description: Rollup aware chains for wagmi
Author: roninjin10
Latest version: 0.0.3

<p align="center"><b></b></p>
<p align="center">Rollup aware chains objects extending wagmi<b>
</b></p>

# rollup-chains • [![CI](https://github.com/roninjin10/rollupChains/actions/workflows/tests.yml/badge.svg)](https://github.com/roninjin10/rollupChains/actions/workflows/tests.yml)

A simple drop in replacement for [wagmis existing chain object](https://github.com/wagmi-dev/references/tree/27c9ee2258c5ba75a93db4cfe5f0e6a791e05b80/packages/chains)

The source code is very small just 1 file [src/rollupChains.ts](https://github.com/roninjin10/rollupChains/blob/main/src/rollupChains.ts). But this simple abstraction can really clean up your code significantly if your DAPP is multichain

## Installation

npm

```bash
npm i @roninjin10/rollup-chains
```

pnpm

```bash
pnpm i @roninjin10/rollup-chains
```

yarn

```bash
yarn add @roninjin10/rollup-chains
```

## Usage

[Use just like @wagmi/chains](https://wagmi.sh/core/chains) but with some extra rollup properties

```typescript
// import {mainnet, optimism} from 'wagmi/chains'
import { mainnet, optimism } from "@roninjin10/rollup-chains";

// the extend wagmi interface
mainnet.id
optimism.rpcUrls

// with added rollup specific properties
mainnet.l1 // returns mainnet
mainnet.l2 // returns optimism
optimism.12 // returns optimism
optimism.l1 // returns mainnet
optimism.isL2 // returns true
optimism.isL2 // returns false
```

## Why

Instead of writing bugprone and unergonomic code like this

```typescript
const currentChainId = connectChain.id
const l1ChainId = connectedChain.id === 1 ? 1 : connectedChain.id === 10 ? 1 : connectedChain.id === 5 ? 5 : connectedChain.id === 420 ? 5 ...
```

Or needing to add helper functions simply swap these chains in for wagmi chains to get rollup aware chains!

```typescript
const currentChainId = connectedChain.id;
// this will return the l1 chain regardless of if user is connected to testnet, mainnet, l1, or l2
const l1ChainId = connectedChain.l1.id;
```

### Author: Will Cory 👨🏻‍💻

<a href="https://twitter.com/fucory">
    <img alt="Twitter" src="https://img.shields.io/twitter/url.svg?label=%40fucory&style=social&url=https%3A%2F%2Ftwitter.com%2Ffucory" />
</a>
```
npm package: @roninjin10/rollupchains
Description: Rollup aware chains for wagmi
Author: roninjin10
Latest version: 0.0.7

<p align="center"><b></b></p>
<p align="center">Rollup aware chains objects extending wagmi<b>
</b></p>

# rollup-chains • [![CI](https://github.com/roninjin10/rollupChains/actions/workflows/tests.yml/badge.svg)](https://github.com/roninjin10/rollupChains/actions/workflows/tests.yml)

A simple drop in replacement for [wagmis existing chain object](https://github.com/wagmi-dev/references/tree/27c9ee2258c5ba75a93db4cfe5f0e6a791e05b80/packages/chains)

The source code is very small just 1 file [src/rollupChains.ts](https://github.com/roninjin10/rollupChains/blob/main/src/rollupChains.ts). But this simple abstraction can really clean up your code significantly if your DAPP is multichain

## Installation

npm

```bash
npm i @roninjin10/rollup-chains
```

pnpm

```bash
pnpm i @roninjin10/rollup-chains
```

yarn

```bash
yarn add @roninjin10/rollup-chains
```

## Usage

[Use just like @wagmi/chains](https://wagmi.sh/core/chains) but with some extra rollup properties

```typescript
// import {mainnet, optimism} from 'wagmi/chains'
import { mainnet, optimism } from "@roninjin10/rollup-chains";

// the extend wagmi interface
mainnet.id
optimism.rpcUrls

// with added rollup specific properties
mainnet.l1 // returns mainnet
mainnet.l2 // returns optimism
optimism.12 // returns optimism
optimism.l1 // returns mainnet
optimism.isL2 // returns true
optimism.isL2 // returns false
```

## Why

Instead of writing bugprone and unergonomic code like this

```typescript
const currentChainId = connectChain.id
const l1ChainId = connectedChain.id === 1 ? 1 : connectedChain.id === 10 ? 1 : connectedChain.id === 5 ? 5 : connectedChain.id === 420 ? 5 ...
```

Or needing to add helper functions simply swap these chains in for wagmi chains to get rollup aware chains!

```typescript
const currentChainId = connectedChain.id;
// this will return the l1 chain regardless of if user is connected to testnet, mainnet, l1, or l2
const l1ChainId = connectedChain.l1.id;
```

### Author: Will Cory 👨🏻‍💻

<a href="https://twitter.com/fucory">
    <img alt="Twitter" src="https://img.shields.io/twitter/url.svg?label=%40fucory&style=social&url=https%3A%2F%2Ftwitter.com%2Ffucory" />
</a>
```
npm package: @roninjin10/sdk
Description: [Optimism] Tools for working with Optimism
Author: Optimism PBC
Latest version: 1.9.1


# @eth-optimism/sdk

[![codecov](https://codecov.io/gh/ethereum-optimism/optimism/branch/master/graph/badge.svg?token=0VTG7PG7YR&flag=sdk-tests)](https://codecov.io/gh/ethereum-optimism/optimism)

The `@eth-optimism/sdk` package provides a set of tools for interacting with Optimism.

## Installation

```
npm install @eth-optimism/sdk
```

## Docs

You can find auto-generated API documentation over at [sdk.optimism.io](https://sdk.optimism.io).

## Using the SDK

### CrossChainMessenger

The [`CrossChainMessenger`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/sdk/src/cross-chain-messenger.ts) class simplifies the process of moving assets and data between Ethereum and Optimism.
You can use this class to, for example, initiate a withdrawal of ERC20 tokens from Optimism back to Ethereum, accurately track when the withdrawal is ready to be finalized on Ethereum, and execute the finalization transaction after the challenge period has elapsed.
The `CrossChainMessenger` can handle deposits and withdrawals of ETH and any ERC20-compatible token.
Detailed API descriptions can be found at [sdk.optimism.io](https://sdk.optimism.io/classes/crosschainmessenger).
The `CrossChainMessenger` automatically connects to all relevant contracts so complex configuration is not necessary.

### L2Provider and related utilities

The Optimism SDK includes [various utilities](https://github.com/ethereum-optimism/optimism/blob/develop/packages/sdk/src/l2-provider.ts) for handling Optimism's [transaction fee model](https://community.optimism.io/docs/developers/build/transaction-fees/).
For instance, [`estimateTotalGasCost`](https://sdk.optimism.io/modules.html#estimateTotalGasCost) will estimate the total cost (in wei) to send at transaction on Optimism including both the L2 execution cost and the L1 data cost.
You can also use the [`asL2Provider`](https://sdk.optimism.io/modules.html#asL2Provider) function to wrap an ethers Provider object into an `L2Provider` which will have all of these helper functions attached.

### Other utilities

The SDK contains other useful helper functions and constants.
For a complete list, refer to the auto-generated [SDK documentation](https://sdk.optimism.io/)
npm package: @roninjin10/smithy
Description: A cli wrapper around forge especially useful for beginners
Latest version: 0.0.1

<a href="https://twitter.com/fucory">
    <img alt="Twitter" src="https://img.shields.io/twitter/url.svg?label=%40fucory&style=social&url=https%3A%2F%2Ftwitter.com%2Ffucory" />
</a>

# [![CI](https://github.com/roninjin10/stax/actions/workflows/tests.yml/badge.svg)](https://github.com/roninjin10/stax/actions/workflows/tests.yml)

# Smithy

Smithy is a handly cli wrapper around forge especially useful for beginners

[Put gif here]

## Installation

Install with npm

```bash
npm i @roninjin10/smithy --global
```

Now run smithy with `smithy` `smithy cast` `smithy forge` or `smithy chisel`
npm package: @roninjin10/ts-sol
Description: A typesafe library for writing forge scripts in typescript
Latest version: 0.0.1

# babel-plugin-sol

**Note this is just a proof of concept and will change heavily in future versions**

A babel plugin for transpiling template string solidity from ts-sol

## Usage

To use you must add the ts-sol babel plugin

### Install dependencies

_Currently not published to npm as it's experimental_

```bash
pnpm i @roninin10/ts-sol @roninjin10/babel-plugin-sol
```

### Add to babel.config.js

```typescript
export default (api) => {
  return {
    plugins: ['@roninjin10/babel-plugin-sol'],
  }
}
```

### Now you can write solidity with ts-sol

```typescript
import { run, tsSol } from '@roninjin10/ts-sol'
import { useState } from 'react'

const forgeScript = tsSol`
contract Script {
    function run() external returns (string memory) {
        return "Hello, World!";
    }
}
`
const sayHello = (): Promise<string> => run(forgeScript)
```
npm package: @roninjin10/typesafe-env
Description: A light wrapper around zod for validating environment variables
Latest version: 0.0.1

<a href="https://twitter.com/fucory">
    <img alt="Twitter" src="https://img.shields.io/twitter/url.svg?label=%40fucory&style=social&url=https%3A%2F%2Ftwitter.com%2Ffucory" />
</a>

# typesafe-env

Simple package for creating typesafe envs. It is a very light wrapper around [zod](https://github.com/colinhacks/zod)

## Getting started

1. Install typesafe-env

```bash
npm i -D @roninjin10/typesafe-env
```

2. Install peer dependencies if not already installed

```bash
npm i -D @roninjin10/typesafe-env
```

3. Create a config for your env variables

```typescript
const validators = {
  // Provide a description if you want to automatically generate documentation
  SERVICE_URI: z.string().url().describe('The URI to connect to ')

  HOST: z.string().default('localhost').describe(`HOST server should connect to
       Must be set to 0.0.0.0 in a docker container`),

  PORT: z
    .string()
    .transform((val) => Number.parseInt(val))
    .default('7300')
    .describe('PORT server should connect to'),
}
```

4. Parse process.env (or any other object)

```typescript
import { typesafeEnv } from '@roninjin10/typesafe-env'
export const env = typesafeEnv(validators, process.env)
env.PORT // type number
env.HOST // type string
// @ts-expect-error
env.NOT_ON_ENV
```

You now have an env object that will be 100% typesafe with autocompletion in your editor! This will defend against misconfigurations.

### Automatically generate documentation

typesafe-env provides an easy way of turning your env validators into documentation

`envSchema.ts`

```typescript
import { validators } from './env'
import { generateEnvDocs } from '@roninjin10/typesafe-env'

console.log(generateEnvDocs)
```

Then if you run `ts-node envSchema` you will get this printed to console

```
Environment Variables schema

SERVICE_URI
    The URI to connect to

HOST
    HOST server should connect to

PORT
    PORT server should ocnnect to
```

### Contributing

All of @roninjin10 is open to contributions! To get started follow these steps

1. Clone the repo
2. Install pnpm `npm install -g pnpm`
3. Install node modules `pnpm install`
4. Cd to typesafe-env `cd packages/typesafe-env`
5. Run the tests `pnpm test`
6. Run the build `pnpm build`

#### Author: Will Cory 👨🏻‍💻
npm package: @roninjin10/typesafe-growthbook
Description: A light wrapper around growthbook based on zod
Latest version: 0.0.1

<a href="https://twitter.com/fucory">
    <img alt="Twitter" src="https://img.shields.io/twitter/url.svg?label=%40fucory&style=social&url=https%3A%2F%2Ftwitter.com%2Ffucory" />
</a>

# typesafe-growthbook

A light easy to configure typesafe wrapper around [@growthbook/react](https://docs.growthbook.io/) providing runtime validation and typesafety with [zod](https://github.com/colinhacks/zod)

## Getting started

1. Install @roninjin10/typesafe-env

```bash
npm i @roninjin10/typesafe-env
```

2. Install peer dependencies

```bash
npm i @growthbook/growthbook-react zod react
```

3. Specify your flags and initialize Growthbook

```typescript
import { flag, TypesafeGrowthbook } from '@roninjin10/typesafe-growthbook'

const flags = {
  myBoolFlag: flag.bool,
  myStringFLag: flag.string,
  myUrlFlag: flag.url,
  myNumberFlag: flag.number,
}

export const growthbook = new TypesafeGrowthbook(flags)
```

4. Initialize the react api if you are using react

```typescript
export const { Provider, useFeature, IfFeatureEnabled, FeatureString } =
  initGrowthbookReact(growthbook)
```

You now have a version of growthbook that has full typesafety! The zod validators will validate your feature flags and throw an error if they are misconfigured.

All react hooks and growthbook methods will infer flag ids and value types from the flag object you provided!

### Flag validators

Flag validators are provided for all types of flags supported by growthbook.

- flag.bool
- flag.url
- flag.string
- flag.number
- flag.stringArray
- flag.numberArray

To make a JSON feature flag use [z.object from zod](https://zod.dev/?id=objects)

```typescript
import {z} from 'zod'

const flags = {
  myJsonFlag: z.object({
    ...
  })
}
```

### Creating a default fallback

Sometimes we don't want to crash the entire app when flag validation fails. In this case you can create a fallback value.

```typescript
import { flag } from '@roninjin10/typesafe-growthbook'
const flags = {
  backedUrl: flag.url().catch('http://default-url-fallback'),
}
```

### Creating an optional value

We can also create optional values with zod if the flag is optional

```typescript
import { flag } from '@roninjin10/typesafe-growthbook'
const flags = {
  backedUrl: flag.bool().optional(),
}
```

### What's changed from growthbook

TypesafeGrowthbook is a typesafe wrapper around growthbook with no changes to the Growthbook API. It simply adds type safety.

Refer to the [growthbook docs](https://docs.growthbook.io/lib/js) for more information on their api

### Contributing

All of @roninjin10 is open to contributions! To get started follow these steps

1. Clone the repo
2. Install pnpm `npm install -g pnpm`
3. Install node modules `pnpm install`
4. Cd to typesafe-env `cd packages/typesafe-env`
5. Run the tests `pnpm test`
6. Run the build `pnpm build`
7. Optionally spin up the example app `nx dev` or `docker-compose up`
8. Run only typesafe growthbook tests `nx test @roninjin10/typesafe-gorwthbook`

#### Author: Will Cory 👨🏻‍💻
npm package: @roninjin10/usedapp-rainbowkit-adapter
Description: A light wrapper around growthbook based on zod
Latest version: 0.0.2

<p align="center"><a href="https://www.growthbook.io"><img src="https://cdn.growthbook.io/growthbook-logo@2x.png" width="400px" alt="GrowthBook - Open Source Feature Flagging and A/B Testing" /></a></p>
<p align="center"><b>Community created typesafe feature flags with Growthbook</b></p>
<p align="center"><b>
  <a href="https://twitter.com/fucory">
      <img alt="Twitter" src="https://img.shields.io/twitter/url.svg?label=%40fucory&style=social&url=https%3A%2F%2Ftwitter.com%2Ffucory" />
  </a>
</b></p>

# usedapp-rainbowkit-adapter

A simple react component that connects rainbowkit to usedapp. This is used by [OP Labs](https://www.oplabs.co/) in the [optimism gateway](https://app.optimism.io/bridge/deposit)

## Getting started

1. Install @roninjin10/usedapp-rainbowkit-adapter

```bash
npm i @roninjin10/typesafe-growthbook
```

2. Nest the adapter inside of your DappProvider

Follow rainbowkit docs to set up a rainbowkit as normal and then nest the adapter inside of your DappProvider

```typescript
return (
  <WagmiConfig client={wagmiClient}>
    <RainbowKitProvider
      chains={wagmiChains}
      theme={rainbowThemes[theme]}
      appInfo={{
        appName: APP_NAME,
        learnMoreUrl: externalRoutes.HOW_DO_I_START,
        disclaimer: RainbowKitDisclaimer,
      }}
      modalSize="compact"
    >
      <DAppProvider
        config={{
          readOnlyChainId: Mainnet.chainId,
          readOnlyUrls: readOnlyUrls as any,
          autoConnect: false,
          pollingInterval: 10_000,
          networks: [
            ...DEFAULT_SUPPORTED_CHAINS,
            chains.OptimismGoerli,
            chains.Devnet,
            chains.OptimismDevnet,
          ],
        }}
      >
        <UseDappRainbowKitAdapter />
        {restOfYourApp}
      </DAppProvider>
    </RainbowKitProvider>
  </WagmiConfig>
)
```

### Author: Will Cory 👨🏻‍💻
npm package: @roninjjj/randomize
Description: Easily include random number generation in your projects. Whether if it's a 2 item 50/50, or a 20 item lootbox, all you need is a simple object!
Author: roninjjj
Latest version: 1.0.1

## How to use
Using Randomize is straightforward. You only need an object, put the item as the key, and the chance to get the item as it's value.
>
> Make sure the sum of your values is exactly 100.
```ts
import randomize from "@roninjjj/randomize"

randomize({
    FiftyPercentChance_ToGetThis: 50,
    ThirtyPercentChance_ToGetThis: 30,
    TwentyPercentChance_ToGetThis: 20
})
```

## Examples
```ts
import randomize from "@roninjjj/randomize"

randomize({
    heads: 50, //50%
    tails: 50
}) // "heads" | "tails"

randomize({
    silver: 20, // 20%
    bronze: 70, 
    gold: 10
}) // "bronze" | "silver" | "gold"

randomize({
    jackpot: 0.1, // 0.1%
    fail: 60.4, 
    success: 39.5
}) // "fail" | "success" | "jackpot"
```
npm package: @roninnetwork/wallet-sdk
Description: A fast and convenient way to integrate Ronin into your Javascript-based apps. Currently support Ronin Extension Wallet and Ronin Mobile Wallet.
Latest version: 1.1.0
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Ronin Wallet SDK

A fast and convenient way to integrate Ronin into your Javascript-based apps. Currently
support Ronin Extension Wallet and Ronin Mobile Wallet.

# Getting started

## 1. Install the SDK

```shell
npm install @roninnetwork/wallet-sdk @walletconnect/modal
```
or
```shell
yarn add @roninnetwork/wallet-sdk @walletconnect/modal
```

## 2. Import and initialize

```javascript
import { WalletSDK } from '@roninnetwork/wallet-sdk'
const sdk = new WalletSDK()
```

## 3. Connect and request

```javascript
const onClickConnect = async () => {
  // Auto detect environment.
  await sdk.connect()
  
  // Or connect only through WalletConnect or Injected Provider
  await sdk.connectInjected()
  await sdk.connectMobile()
  
  // Check if session exists and wallet is unlocked
  let accounts = await sdk.getAccounts()
  if(!accounts.length) {
    // Request unlock wallet & session approval
    accounts = await sdk.requestAccounts()
  }
}

// Example of a sign request
const onClickSignMessage = async () => {
  const signature = await sdk.request({ 
    method: 'personal_sign',
    params: ['Hello World', currentAccount.address]
  })
}
```

# Full documentation
Please read the full documentation at: https://docs.skymavis.com/ronin/wallet/reference/js-sdk-reference

# Contributing
See [the contributing guide](CONTRIBUTING.md) for detailed instructions on how to get started with our project.
npm package: @roninski/password-utilities
Description: A small js library that provides password utility functions
Author: if22b080 + if22b208
Latest version: 1.0.1

# @roninski/password-utilities (Class 3 evaluated exercise)

> A small JavaScript library that provides password utility functions.

## Table of Contents

- [Installation](#installation)

- [Usage](#usage)

    - [Examples](#examples)

- [Contribution](#contribution)

- [Security](#security)

- [License](#license)

## Installation

Install via npm:

```bash
npm install @roninski/password-utilities
```

Install via yarn:

```bash
yarn add @roninski/password-utilities
```

## Usage

Basic Usage

```js
import passwordUtilityModule from '@roninski/password-utilities';

const {generateStrongPassword} = passwordUtilityModule;

const password = generateStrongPassword(8);

console.log(password);       // e.g., "pCw01mW@"
```



```js
import passwordUtilityModule from '@roninski/password-utilities';

const {isStrongPassword} = passwordUtilityModule;

const password = "pCw01mW@";

const isStrong = isStrongPassword(password);

console.log(isStrong);       // e.g., "true" or "false"
```

## Contribution

Contributions are welcome! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.

## Security

Please refer to our [SECURITY.md](./SECURITY.md) for information about our security policies, how to report
vulnerabilities, and our approach to handling security concerns.

## License

This project is licensed under the [MIT License](./LICENSE.md).
npm package: @roninski/shuffle-array
Description: A small library that takes an array as input and returns a new array that is shuffled.
Latest version: 0.2.1

# @roninski/shuffle-array (Class 2 Example)

> A small library that takes an array as input and returns a new array that is shuffled.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
   - [Examples](#examples)
- [Contribution](#contribution)
- [Security](#security)
- [License](#license)

## Installation

Install via npm:

```bash
npm install @roninski/shuffle-array
```
Install via yarn:

```bash
yarn add @roninski/shuffle-array
```

## Usage

Basic Usage

```js
import shuffleModule from '@roninski/shuffle-array';

const {shuffleArray} = shuffleModule;

const startArray = [1, 2, 3, 4, 5];
const newShuffledArray = shuffleArray(startArray);

console.log(startArray);       // e.g., [1, 2, 3, 4, 5]
console.log(newShuffledArray); // e.g., [3, 1, 5, 2, 4]
```

```js
import shuffleModule from '@roninski/shuffle-array';

const {cryptoShuffleArray} = shuffleModule;

const startArray = [1, 2, 3, 4, 5];
const newShuffledArray = cryptoShuffleArray(startArray);

console.log(startArray);       // e.g., [1, 2, 3, 4, 5]
console.log(newShuffledArray); // e.g., [3, 1, 5, 2, 4]
```

### Examples

Shuffle a list of user IDs:

```js
import shuffleModule from '@roninski/shuffle-array';

const {shuffleArray} = shuffleModule;

const userIds = ['u1', 'u2', 'u3', 'u4'];
const randomizedOrderOfUserIds = shuffleArray(userIds);

console.log(randomizedOrderOfUserIds); // e.g., ['u1', 'u3', 'u4', 'u2']
```

```js
import shuffleModule from '@roninski/shuffle-array';

const {cryptoShuffleArray} = shuffleModule;

const userIds = ['u1', 'u2', 'u3', 'u4'];
const randomizedOrderOfUserIds = cryptoShuffleArray(userIds);

console.log(randomizedOrderOfUserIds); // e.g., ['u1', 'u3', 'u4', 'u2']
```

Use in a game for randomizing cards:

```js
import shuffleModule from '@roninski/shuffle-array';

const {shuffleArray} = shuffleModule;

const deck = ['Ace of Spades', 'Two of Hearts']; // some card deck
const shuffledDeck = shuffleArray(deck);

console.log(shuffledDeck); // e.g., ['Two of Hearts', 'Ace of Spades', ...]
```

```js
import shuffleModule from '@roninski/shuffle-array';

const {cryptoShuffleArray} = shuffleModule;

const deck = ['Ace of Spades', 'Two of Hearts']; // some card deck
const shuffledDeck = cryptoShuffleArray(deck);

console.log(shuffledDeck); // e.g., ['Two of Hearts', 'Ace of Spades', ...]
```

## Contribution

Contributions are welcome! Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more details.

## Security

Please refer to our [SECURITY.md](./SECURITY.md) for information about our security policies, how to report vulnerabilities, and our approach to handling security concerns.

**Important Note**: This library uses non-cryptographic randomness (`Math.random()`). Do not rely on it for security-critical functionality.

## License

This project is licensed under the [MIT License](./LICENSE.md).
npm package: @roninski/string-toolkit
Description: A lightweight JavaScript utility library designed for transforming strings into different cases.
Latest version: 1.1.0

# @roninski/string-toolkit
A lightweight JavaScript utility library designed for transforming strings into different cases.

## Table of Contents

- [Current functions](#current-functions)
- [Installation](#installation)
- [Usage](#usage)
- [Running Tests](#running-tests)
- [Contribution](#contribution)
- [Security](#security)
- [License](#license)

## Current functions
- **toSnakeCase:** Converts a string to snake_case.
- **toKebabCase:** Converts a string to kebab-case.

## Installation
Install via **npm**:
```bash
npm install @roninski/string-toolkit
```

or via yarn
```bash
yarn add @roninski/string-toolkit
```

## Usage
```js
const { toSnakeCase, toKebabCase } = require('@roninski/string-toolkit');

console.log(toSnakeCase("Hello World")); // Output: "hello_world"
```

```js
const { toKebabCase } = require('@yourname/string-toolkit');
console.log(toKebabCase("Hello World")); // Output: "hello-world"
```


## Running Tests
This project uses Jest for unit testing. To run the tests, execute:
```
npm test
```

## Contributing
We welcome contributions! Please refer to our [CONTRIBUTING.md](./CONTRIBUTING.md) for detailed guidelines on submitting issues and pull requests.

## Security

Please refer to our [SECURITY.md](./SECURITY.md) for information about our security policies, how to report vulnerabilities, and our approach to handling security concerns.

## License
This project is licensed under the MIT License. See [LICENSE.md](./LICENSE.md) for more details.