open-index/open-npm huggingface dataset:
npm package: @rbxts/chroma
Description: A lightweight theming system for creating context-aware UI themes in Roblox with [@rbxts/vide](https://github.com/littensy/vide).
Author: longuint-rbx
Latest version: 1.0.4

# 🎨 @rbxts/chroma

A lightweight theming system for creating context-aware UI themes in Roblox with [@rbxts/vide](https://github.com/littensy/vide).

---

## 📦 Installation

```bash
npm install @rbxts/chroma
```

## 🛠️ License

MIT
npm package: @rbxts/clack
Description: User input helper classes
Author: sleitnick
Latest version: 3.1.1

# Clack

User input helper classes.

## Examples

Below are examples of the input classes. The examples are not an exhaustive list of the APIs available.

### Preferred Input

The preferred input is based on the last input the user has made. Because players can change their desired input during gameplay, it is helpful to watch for these changes in order to help direct the player in the best way possible.

For instance, if there are UI elements that show the player the control schema for the game, using `observePreferredInput` can be used to dynamically change this display if the user switches between using a gamepad and using a mouse/keyboard.

```ts
const prefer = new Prefer();

print(`Preferred: ${tostring(prefer.getPreferredInput())}`);

prefer.observePreferredInput((preferred) => {
	print(`Preferred: ${tostring(preferred)}`);
	if (preferred === Clack.InputType.MouseKeyboard) {
		print("Prefer mouse and keyboard");
	} else if (preferred === Clack.InputType.Touch) {
		print("Prefer touch");
	} else if (preferred === Clack.InputType.Gamepad) {
		print("Prefer gamepad");
	}
});
```

### Mouse

Watch for mouse input.

```ts
const mouse = new Mouse();

mouse.getButtonDownSignal(Enum.UserInputType.MouseButton1).Connect((position) => {
	print("Left button down", position);
});

print(mouse.getPosition());

const result = mouse.raycast(new RaycastParams());
```

### Keyboard

Watch for keyboard input.

```ts
const keyboard = new Keyboard();

keyboard.keyDown.Connect((keyCode) => {
	print(`Key down: ${tostring(keyCode)}`);
});

keyboard.keyUp.Connect((keyCode) => {
	print(`Key up: ${tostring(keyCode)}`);
});

print("W down", keyboard.isKeyDown(Enum.KeyCode.W));

print("CTRL+S", keyboard.isKeyComboDown(Enum.KeyCode.LeftControl, Enum.KeyCode.S));

print("Forward", keyboard.isEitherKeyDown(Enum.KeyCode.W, Enum.KeyCode.Up));
```

### Gamepad

Watch for gamepad input.

```ts
const gamepad = new Gamepad();

gamepad.buttonDown.Connect((button) => {
	print(`Button down: ${tostring(button)}`);
});

gamepad.setMotor(Enum.VibrationMotor.Large, 1);
gamepad.stopMotor(Enum.VibrationMotor.Large);
gamepad.pulseMotor(Enum.VibrationMotor.Large, 1, 0.2);

const leftThumbstickPos = gamepad.getThumbstick(Enum.KeyCode.Thumbstick1);
print(`Left thumbstick position: ${tostring(leftThumbstickPos)}`);
```

### Touch

Watch for touch input.

```ts
const touch = new Touch();

touch.getTouchTapSignal().Connect((touchPositions, processed) => {
	print("Touched");
});
```
npm package: @rbxts/clan-labs
Description: An object-orientated TypeScript implementation of all public known ClanLabs apis.
Latest version: 1.0.3

<div align="center"><img width=25% src="https://clanlabs.co/resources/logo.png"></div>
<h1 align="center">Clan Labs TS</h1>
<div align="center">
    <a href="https://github.com/roblox-ts/roblox-ts">
		<img src="https://img.shields.io/badge/github-roblox_typescript-red.svg" alt="roblox-ts"></img>
	</a>
</div>

<div align="center">
	An object-orientated TypeScript implementation of all public known ClanLabs apis.

    ClanLabs website: https://clanlabs.co/
    ClanLabs discord: https://discord.com/invite/A7bSWBw

</div>

<div>&nbsp;</div>

## Installation

You can install it via `npm i @rbxts/clan-labs`.
npm package: @rbxts/cldr
Description: [CLDRTools, a tool for formatting/shortening numbers, getting plurals etc. (Undocumented!)](https://devforum.roblox.com/t/cldrtools-a-tool-for-formattingshortening-numbers-getting-plurals-etc-undocumented/539614)
Author: woder
Latest version: 1.1.0

# Original Lua CLDRTools

[CLDRTools, a tool for formatting/shortening numbers, getting plurals etc. (Undocumented!)](https://devforum.roblox.com/t/cldrtools-a-tool-for-formattingshortening-numbers-getting-plurals-etc-undocumented/539614)
npm package: @rbxts/cleanser
Description: A port of RobloxianDemo's Cleanser class.
Author: RobloxianDemo
Latest version: 2.1.0

# Cleanser

Cleanser is a highly personalized, all-in-one, and lightweight implementation served for garbage collection.

## Installation

### 📦 — NPM:

```
npm i @rbxts/cleanser
```

### 🧶 — Yarn:

```
yarn add @rbxts/cleanser
```

### 📀 — pnPM:

```
pnpm add @rbxts/cleanser
```

## Cleanser API

### Types

```ts
interface Destroyable {
	TimedDestroy(waitTime: number): boolean;
	Cleanse(): void;
	Destroy(): void;
}

type Object =
	| never
	| undefined
	| ((this: defined) => void)
	| ((_: defined) => void)
	| ExtractKeys<defined, () => void>
	| thread
	| RBXScriptConnection
	| Cleanser
	| Cleanser.Destroyable;
```

### Constructor

```ts
const cleanser = new Cleanser.Cleanser<{ Instances: Array<Instance> }>();
```

### `Cleanser.Is`

```ts
public Is(
		object?: T extends Cleanser.Object | Cleanser.Destroyable | true ? RBXScriptConnection : T | defined,
	): boolean;
```

Returns whether or not the specified class is a valid Cleanser.

### `Cleanser.Grant`

```ts
public Grant(object?: T extends Cleanser.Object | Cleanser.Destroyable | true ? RBXScriptConnection : T |   defined,
	): Cleanser;
```

Grant a new cleanser task.

### `Cleanser.TimedDestroy`

```ts
public TimedDestroy(waitTime: number): boolean;
```

Destroy and cleanup a cleanser after a certain amount of time has elapsed.

### `Cleanser.Cleanse`

```ts
public Cleanse(): void;
```

Cleanse the specified cleanser object(s).

### `Cleanser.Destroy`

```ts
public Destroy(): void;
```

Destroy and cleanup a Cleanser (making it unusable).

## Example

```ts
// Services
import { Workspace } from "@rbxts/services";

// Modules
import { Cleanser } from "@rbxts/cleanser";

// Functions
const Part = new Instance("Part");
Part.Name = "Part";
Part.Position = new Vector3(0, 5, 0);
Part.Size = new Vector3(5, 1, 5);
Part.Parent = Workspace;

const PartCleanser = new Cleanser.Cleanser(Part);
task.wait(3);
PartCleanser.Cleanse();
```
npm package: @rbxts/cmdr
Description: <div align="center"> 	<img src="assets/logo.png" alt="Cmdr" height="150" /> 	<br> 	<a href="https://discord.gg/g5PdMxh"><img src="https://img.shields.io/discord/425800792679645204.svg?label=discord" /></a> 	<p><a href="https://eryn.io/Cmdr/">View Docs</a>
Latest version: 1.12.1

<div align="center">
	<img src="assets/logo.png" alt="Cmdr" height="150" />
	<br>
	<a href="https://discord.gg/g5PdMxh"><img src="https://img.shields.io/discord/425800792679645204.svg?label=discord" /></a>
	<p><a href="https://eryn.io/Cmdr/">View Docs</a></p>
</div>

**Cmdr** is a fully extensible and type safe command console for Roblox developers.

- Great for admin commands, but does much more.
- Make commands that tie in specifically with your game systems.
- Intelligent autocompletion and instant validation.
- Run commands programmatically on behalf of the local user.
- Bind commands to user input.
- Secure: the client and server both validate input separately.
- Embedded commands: dynamically use the output of an inner command when running a command.

<p align="center">
  <a href="https://giant.gfycat.com/HatefulTanAzurewingedmagpie.mp4"><img src="https://thumbs.gfycat.com/HatefulTanAzurewingedmagpie-size_restricted.gif" alt="Demo video" /></a>
</p>
npm package: @rbxts/color
Description: Color ============= Library for manipulating colors
Latest version: 0.1.4

Color
=============
Library for manipulating colors


## isDark(color: Color3): boolean
Uses the YIQ equation to determine if the specified color is dark

## isLight(color: Color3): boolean
Opposite of `isDark`. Equivalent to `!isDark(color)`

## invert(color: Color3): Color3
Inverts the specified color

## greyscale(color: Color3): Color3)
Turns the color into greyscale

## toHex(color: Color3, uppercase?: boolean): string
Converts the color to a hexadecimal format (e.g. #FF00FF)

## fromHex(hex: string): Color3
Converts a hexadecimal string to a Color3 value.
Expects RRGGBB `#FF00FF` or RGB `#F0F` hex formats. `#` prefix is optional.

## gradient(colors: Array<Color3>, goal: number): Color3
Using an array of colours, gets the color in the gradient from the `goal`.

Example:

```ts
const gradient = [
	Color3.fromRGB(255, 0, 0),
	Color3.fromRGB(255, 255, 0),
];

const betweenRedAndYellow = Color.gradient(gradient, 0.5);
const moreRedThanYellow = Color.gradient(gradient, 0.25);
const moreYellowThanRed = Color.gradient(gradient, 0.75);
const red = Color.gradient(gradient, 0);
const yellow = Color.gradient(gradient, 1);
```


## fromUInt24(uint24: u24): Color3
Creates a colour from an unsigned integer

## toUInt24(color: Color3): u24
Turns a colour into an unsigned integer
npm package: @rbxts/colour-utils
Description: Colour manipulation utility for Roblox
Author: csqrl
Latest version: 1.4.1

<!-- Project Link References -->

[repo]: https://github.com/csqrl/colour-utils
[releases]: https://github.com/csqrl/colour-utils/releases
[library]: https://create.roblox.com/marketplace/asset/6573728888
[npm]: https://npmjs.com/package/@rbxts/colour-utils

<!-- Images -->

[shield/ghv]: https://img.shields.io/github/v/release/csqrl/colour-utils?label=latest+release&style=flat
[shield/npmv]: https://img.shields.io/npm/v/@rbxts/colour-utils?style=flat
[shield/wallyv]: https://img.shields.io/endpoint?url=https://runkit.io/clockworksquirrel/wally-version-shield/branches/master/csqrl/colour-utils&color=blue&label=wally&style=flat

<!-- Badges -->

[badge/github]: https://raw.githubusercontent.com/gist/csqrl/56c5f18b229ca1e61feb6eb5fb149f43/raw/githubSource.svg
[badge/npm]: https://raw.githubusercontent.com/gist/csqrl/56c5f18b229ca1e61feb6eb5fb149f43/raw/npm.svg

# ColorUtils

<div align="center">

[![Source Code][badge/github]][repo] [![NPM][badge/npm]][npm]

[![Releases][shield/ghv]][releases] [![NPM][shield/npmv]][npm] [![Wally][shield/wallyv]][releases]

</div>

ColorUtils is a utility library for Roblox Studio that provides a number of
functions for working with colors.

The library contains methods to manipulate standard `Color3`s, as well as convert
them back and forth between formats; such as Hex and Integer _(great for Discord!)_.

ColorUtils can also generate color palettes, blend colors together, and even
simulate color blindness. In combination with the built-in accessibility-focused
"submodules," ColorUtils can be used to find and generate the perfect and most
accessible colors for your project.

## Documentation

Documentation is available at <https://csqrl.github.io/colour-utils>.

## Quick Start

ColorUtils is available in Lua and TypeScript (via roblox-ts). It's available
from the wally and npm registries, Roblox Library and via Itch.io.

> :warning: **Note:** ColorUtils was released on wally and npm using the
> British spelling of "colour" in the package name. Bear this in mind when
> installing the package.

### Wally

```toml
# wally.toml

[dependencies]
ColorUtils = "csqrl/colour-utils@X.X.X"
```

```sh
wally install
```

### TypeScript

Install the [`@rbxts/colour-utils`][npm] package using npm or yarn.

```sh
npm i @rbxts/colour-utils
yarn add @rbxts/colour-utils
```

### Manual Installation

Grab a copy [from the Roblox Library (Toolbox)][library], or download the latest
`.rbxm` file from [the releases page][releases] and drop it into Studio.
npm package: @rbxts/command
Description: Very simple command/argument management system.
Latest version: 0.0.1

# Command

A simple command registration and execution management system including some utilities to parse arguments and disect command strings.
This library is meant to be used with player centric commands, every command must have a player sender, this may not be for you if that's
not what you want.

## Example

A simple example demonstrating argument parsing, command registration and command execution.

```ts
class TargetParser implements ArgumentValueParser<Player> {
	private players = game.GetService('Players');

	public parse(value: string) {
		// TODO you can implement more robust and advanced
		// player parsing, such as checking for a player's
		// name, their ID, whether the name includes the
		// value, etc...

		return this.players.GetPlayers().find((player) => {
			return player.Name.lower() === value.lower();
		});
	}
}

class NumberParser implements ArgumentValueParser<number> {
	public parse(value: string) {
		// TODO you can implement more robust and advanced
		// number parsing, such as a configuration to
		// enable clamping, rounding, etc...

		return tonumber(value);
	}
}

const commander = new Commander();

// Commands can be functions or classes, up to you and your coding style.
commander.registerCommand({ identifier: 'hurt' }, (sender, args) => {
	// Take a look at the doc comments of ArgumentParser and ArgumentDescriptor
	// to find more about how to declaratively parse arguments like this.
	const [target, damage] = args.describe().then(new TargetParser()).then(new NumberParser()).compile();

	const char = target.get(sender).Character;
	if (!char) return;

	const hum = char.FindFirstChildOfClass('Humanoid');
	if (!hum) return;

	hum.Health = hum.Health - damage.get(hum.Health);
});

commander.executeName(game.GetService('Players').LocalPlayer, 'hurt', ['xzyrakia', '5']);
```
npm package: @rbxts/component
Description: A simple tag-based component library for Roblox TS.
Author: typechecked
Latest version: 1.2.0

# @rbxts/component
A simple tag-based component library for Roblox TS.

```ts
import { Component, TagComponent } from "@rbxts/component"
import { RunService } from "@rbxts/services"

@Component({
    Tag: "Rainbow"
})
export class Rainbow extends TagComponent<Part> {
    public ResetColor!: Color3

    public Speed = 100
    public Hue = 0

    public Start() {
        this.ResetColor = this.Instance.Color // we need to remember the part's original color to revert it later

        this.Trove.add(RunService.Heartbeat.Connect((DeltaTime: number) => {
            this.Instance.Color = Color3.fromHSV(this.Hue/360, 1, 1)
            this.Hue += DeltaTime * this.Speed

            if(this.Hue > 360) {
                this.Hue = 0
            }
        })) // we add this to the built in trove so the RenderStepped connection gets disconnected the instance this component is attached to is destroyed, or the Rainbow tag is removed

        this.Trove.add(() => {
            this.Instance.Color = this.ResetColor
        }) // we also want to reset the part to it's original color, so let's do this
    }
}
```
npm package: @rbxts/conf
Description: Instance based configuration management.
Latest version: 0.0.1

<div align="center">
    <h1>Conf</h1>
</div>

Conf is a simple module to get and set variables from a Roblox `Configuration` instance.

## Why Conf?

Conf combines keys and types to allow multiple `ValueBase` instances to exist under the same name, if they hold separate types.

This means that the following code:

```ts
conf.set('apples', true);
conf.set('apples', 10);
```

will result in the following Roblox tree:

```md
Configuration
├── BoolValue "apples": true
└── NumberValue "apples": 10
```

These can be written to and read from individually, but they will
both be deleted together with:

```ts
conf.delete('apples');
```

## Introduction

#### **Existing Values**

In Conf, each `ValueBase` instance is referred to as a `"Store"`. At instantiation, all existing stores are registered, meaning a reference of them is saved into the Conf instance.

Existing stores can be addressed via their instance name, which becomes their key. New stores are created when a new key is written to.

Any changes in the Roblox tree after instantiation are not automatically reflected, but this can be enabled with.

```ts
conf.watchTree();
```

#### **Obtaining Values**

When obtaining values in Conf, you must specify what you are expecting.

This is important to maintain type safety and keys associated with values of multiple types.

```ts
conf.get('apples', 'number');
```

If you would like to prevent the `undefined` result, in the case of the value not existing, you can use the `ensure` method.

```ts
conf.ensure('apples', 5);
```

In this case, Conf infers what type of value you are trying to obtain, and will address the correct store. If no store exists, or the store holds no value (in case of `ObjectValue`), the fallback will be returned. When using the fallback value, no store is created.

#### **Setting Values**

When setting values in Conf, the type of value you are setting is automatically
inferred, and the appropriate store is created, if it does not exist already.

```ts
conf.set('apples', 10); // NumberValue store is created, if it doesn't exist
conf.set('apples', true); // BoolValue store is created, if it doesn't exist
```

#### **Deleting Values**

When deleting values, the key itself is deleted. This means that if multiple stores exist under the same key, they are all deleted.

```ts
conf.set('apples', 10);
conf.set('apples', true);

conf.delete('apples'); // Deletes both the Numbervalue and BoolValue store
```

#### **Instance Tree Synchronization**

Automatic synchronization can be enabled with:

```ts
conf.watchTree();
```

and disabled with:

```ts
conf.ignoreTree();
```

Manual synchronization can be executed with:

```ts
conf.syncTree();
```

Automatic sync does not reflect name changes of stores after they have
been added. This means that if a store instance changes it's name, it's key within Conf will still be the original name.

This issue persists until a manual sync is executed, because a manual sync will re-register all stores.
npm package: @rbxts/constrained-markers
Description: Contains typings for Anaminus's ConstrainedMarkers Module.<br /> See https://devforum.roblox.com/t/constrainedmarkers-module/67640
Latest version: 1.1.0

# ConstrainedMarkersTypings

Contains typings for Anaminus's ConstrainedMarkers Module.<br />
See https://devforum.roblox.com/t/constrainedmarkers-module/67640
npm package: @rbxts/coverage
Description: Coverage instrumentation for Roblox Luau
Latest version: 0.1.3

# Roblox Coverage

Code coverage instrumentation for Roblox Luau modules. This library injects lightweight probes into your ModuleScripts at runtime, collects execution hits, and emits an Istanbul-compatible JSON report that you can feed into standard coverage tooling (HTML, lcov, Cobertura, etc.).

## Features
- Runtime instrumentation of ModuleScripts (no compiler plugin required)
- Istanbul/nyc-compatible JSON output
- Function and branch hit tracking in addition to statements
- Sensible include/exclude defaults (avoids `Packages` and the coverage folder)
- Demo place + script to generate full HTML/text/LCOV/Cobertura reports locally

## How it works
1. `coverage.instrument()` walks your include roots, injects `_G.__covhit`, `_G.__covfn`, and `_G.__covbranch` calls into ModuleScript sources, and tracks IDs per line/function/branch.
2. Your code runs normally; probes increment counters in `_G.__COVERAGE__`.
3. `coverage.istanbul()` converts the collected data to an Istanbul report object you can serialize and post-process with `istanbul-lib-*` or CI tools.

## Quick start (demo)
Prereqs: Node.js, Roblox Studio

If you do not have Roblox Studio installed, you can specify a `ROBLOSECURITY` environment variable of a throwaway account to run Luau on the cloud.

```bash
npm install
npm run demo
```

The demo will:
- Build the example place via Rojo to `demo/place.rbxl`
- Run `demo/test.luau` with rbxluau, which instruments and exercises sample modules
- Emit Istanbul JSON to `demo/coverage/coverage-final.json`
- Generate HTML, lcov, Cobertura, text, and JSON summary reports into `demo/coverage/`

Open `demo/coverage/index.html` in a browser to explore the report.

## Using in your experience
```lua
local coverage = require(game:GetService("ReplicatedStorage").coverage)

-- Instrument common services by default; you can pass explicit roots.
coverage.instrument(
    {
        game:GetService("ServerScriptService"),
        game:GetService("ReplicatedStorage"),
        game:GetService("ServerStorage"),
        game:GetService("StarterPlayer"),
        game:GetService("StarterGui"),
    },
    {
        game:GetService("ReplicatedStorage"):FindFirstChild("Packages"),
    }
)
```

1. Run your tests or gameplay to collect coverage.
2. Export the report where you need it (e.g. to HttpService, DataStore, or a file if running in a CLI environment):

```lua
local HttpService = game:GetService("HttpService")
local report = coverage.istanbul()
local json = HttpService:JSONEncode(report)
-- Persist json as needed
```

## Notes
- This library destructively modifies ModuleScript sources. It's recommended to only enable coverage instrumentation in test environments.
- The instrumentation also adds overhead; expect slower execution times when coverage is enabled.
- Coverage JSON uses Roblox datamodel paths, not filesystem paths. You may need to map these paths when integrating with external tools.
npm package: @rbxts/crunchyroll
Description: A custom animation solver for Roblox.
Author: ffrostfall
Latest version: 0.2.0-ts.4

# Crunchyroll


https://github.com/user-attachments/assets/51bbde10-b439-431e-9e85-a808a9303f0f


no Animator!

---

Crunchyroll is a dedicated library for calculating coordinates frames of a rig from an array of animation tracks. You can define a rig by calling `crunchyroll.create_rig`, which is a representation of Roblox Motor6Ds. You can then pass this rig into `crunchyroll.solve_animation`, which also takes animation tracks. These are tables which are similar to Roblox's `AnimationTrack`s. Similar to AnimationTracks, you need an animation "asset". You can load a Roblox animation by calling `crunchyroll.load_keyframe_sequence`. Crunchyroll will then give you the coordinate frames of the "limbs" (think Torso, Head, "Left Leg", UpperTorso etc.), and that's it!

# Why use this?

If you don't intend on using Crunchyroll to write your own animation player:

- No instances! You can calculate how an animation looks at any given time without affecting your game in any way. This means you could implement things like proper ping compensation and secure hit detection (secure headshot detection!)
- Allows for extremely convenient still shots of characters
- Great for characters in viewport frames! Animations

If you do write your own animation player:

- Numerical priorities! No more Action1, Action2, Action3.
- No more :LoadAnimation() or any asset ID management.
- Immediate stops! No more forced 0.05s fade time.
- Very fast and performant :3
- potential for things like easy animation skipping!
- remove the physics from animations, makes it significantly easier to write your own animation replication!

# Future support

Eventually, I may consider making a custom animation format which supports things like sinusoidal easing, additive blending, and other features. I do not know how popular this would be though so I am not sure I will implement these right now.

# Example

```luau
local rig = require(...) -- Path to a Crunchyroll R6 rig
local crunchyroll = require(...) -- Path to Crunchyroll

local crunchyroll_animation = crunchyroll.load_keyframe_sequence(ReplicatedStorage.assets.TestAnimation)

crunchyroll_animation.solve_animation(rig, {
	[crunchyroll_animation] = {
		stop_fade_time = 0.25, -- 0.25 seconds
		start_fade_time = 0.25,

		weight = 1, -- Supports blending!
		priority = 1, -- Supports numerical priorities!

		alpha = 0.5 -- Halfway through the animation
	}
})

-- placed into a result table for optimal performance
local left_arm_cframe = rig.result_coordinate_frames["Left Arm"]
```
npm package: @rbxts/data-structures
Description: A collection of data structures and algorithms for use in Roblox.
Author: HowManySmall
Latest version: 1.1.0

# Data Structures

### Questions

- Where's Queue?

Just use an array.

```lua
local Queue = {1, 2, 3}
local Popped = table.remove(Queue, 1)
```

- Where's Stack?

Just use an array.

```lua
local Stack = {1, 2, 3}
local Popped = table.remove(Stack)
```

- Where's LinkedList?

Just use an array.

- Where's ArrayList?

Just use an array.

TLDR: I removed some of the more list-like data structures because it's far more efficient in Luau to use an array. You don't
need to have some overcomplicated data structure to use as an array.
npm package: @rbxts/debris
Description: A port of RobloxianDemo's Debris module.
Author: RobloxianDemo
Latest version: 1.1.0

# Debris

Debris is a highly personalized and lightweight application, served as an alternative to Roblox's traditional Debris service.

## Installation

### 📦 — NPM:

```
npm i @rbxts/debris
```

### 🧶 — Yarn:

```
yarn add @rbxts/debris
```

### 📀 — pnPM:

```
pnpm add @rbxts/debris
```

## Debris API

### Types

```ts
type Object<T> = object | thread | RBXScriptConnection | Instance | Array<T> | [] | ItemCache<T>;

type ItemCache<T> = [T];
```

### `Debris.RemoveObject`

```ts
function RemoveObject<T extends Object<Array<T>>>(object: Object<T>, objectClass: string): T;
```

Destroy the specified debris object.

### `Debris.AddObject`

```ts
function AddObject<T extends Object<Array<T>>>(object: Object<T>, lifetime: number): ItemCache<T>;
```

Add the specified debris object.

### `Debris.AddObjectArray`

```ts
function AddObjectArray<T extends Array<Object<Array<T>>>>(
	objects: Array<Object<Array<T>>>,
	lifetime: number,
): ItemCache<T>;
```

Add the specified debris objects.

### `Debris.RetrieveDebris`

```ts
function RetrieveDebris<T extends Object<Array<T>>>(object: Object<T>): ItemCache<T>;
```

Retrieve the specified debris instance's table.

### `Debris.RetrieveAllDebris`

```ts
function RetrieveAllDebris<T extends Array<defined>>(): ItemCache<T>;
```

Retrieve all debris instances.

## Example

```ts
// Services
import { Workspace } from "@rbxts/services";

// Modules
import { AddObject, RemoveObject } from "@rbxts/debris";

// Functions
const Part = new Instance("Part");
Part.Name = "Part";
Part.Position = new Vector3(0, 5, 0);
Part.Size = new Vector3(5, 1, 5);
Part.Parent = Workspace;

AddObject(Part, math.huge);
task.wait(3);
RemoveObject(Part, "Part");
```
npm package: @rbxts/debug-random
Description: A wrapper around Roblox's Random class that enables users to serialize and set the state of the Random object
Author: Tim7775
Latest version: 1.0.3

# DebugRandom

A wrapper around Roblox's [Random](https://create.roblox.com/docs/reference/engine/datatypes/Random) class that enables users to serialize and set the state of the Random object.

Get it here:

- [Wally](https://wally.run/package/tim7775/debug-random)
- [Releases](https://github.com/Tim7775/DebugRandom/releases)
- [Npm (Roblox-ts)](https://www.npmjs.com/package/@rbxts/debug-random)

<!--moonwave-hide-after-this-line-->

## Documentation

[View Documentation](https://tim7775.github.io/DebugRandom/api/DebugRandom)

<!--moonwave-hide-before-this-line-->

## Usage

**Example use:** Serialize a random number generator's state when an error occurs, so the error can be replicated using [DebugRandom:SetSerializedState](https://tim7775.github.io/DebugRandom/api/DebugRandom#SetSerializedState) or [DebugRandom.deserialize](https://tim7775.github.io/DebugRandom/api/DebugRandom#deserialize).

```lua
local rng = DebugRandom.new()
print(rng:NextNumber())

local state = rng:Serialize()
local deserializedRng = DebugRandom.deserialize(state)
assert(rng == deserializedRng)
assert(rng:NextNumber() == deserializedRng:NextNumber())
assert(rng == DebugRandom.fromString(tostring(rng)))
```
npm package: @rbxts/device
Description: Platform/Device helper functions for Roblox
Latest version: 0.1.2

# Device

A utility to get device information.

Useful for knowing what controls to assign to a user, or a custom experience/UI per platform/device.

## GetPlatformType()

Returns the platform type

- `console` - Is XBox 
- `desktop` - Is Windows or MacOS 
- `tablet` - Is iOS or Android tablet 
- `phone` Is iOS or Android phone


## GetAspectRatio
Gets the aspect ratio of the screen

Returns an array of two numbers, e.g. a 1920x1080 screen will give you `[16, 9]`