open-index/open-npm huggingface dataset:
npm package: @profesornoobz1440x/event-propagation
Description: The EventPropagation package is responsible for functionality related to propagating events registered and triggered by consumers. It is a foundational component of the FocusNavigation library.
Latest version: 1.0.6

# EventPropagation

The EventPropagation package is responsible for functionality related to propagating events registered and triggered by consumers. It is a foundational component of the FocusNavigation library.

[View Documentation](https://roblox.github.io/focus-navigation-internal/api-reference/event-propagation/)
npm package: @profesornoobz1440x/focus-behaviors
Description: Defines focus management behaviors that can be attached to containers via the FocusNavigationService. Containers will typically be pages or modals, and focus behaviors will trigger whenever the container gains focus (in other words: when focus moves from 
Latest version: 1.0.5

# FocusBehaviors

Defines focus management behaviors that can be attached to containers via the FocusNavigationService. Containers will typically be pages or modals, and focus behaviors will trigger whenever the container gains focus (in other words: when focus moves from outside the container's hierarchy to inside the container's hierarchy).

[View Documentation](https://roblox.github.io/focus-navigation-internal/api-reference/focus-behaviors/)
npm package: @profesornoobz1440x/focus-navigation
Description: The FocusNavigation package contains UI-library-agnostic behavior intended to drive focus navigation in a generic way.
Latest version: 1.0.6

# FocusNavigationService

The FocusNavigation package contains UI-library-agnostic behavior intended to drive focus navigation in a generic way.

[View Documentation](https://roblox.github.io/focus-navigation-internal/api-reference/focus-navigation/)
npm package: @profesornoobz1440x/focus-navigation-utils
Description: Some small generic utilities used by the FocusNavigationService workspace, set aside so that they can be more easily extracted later if desired
Latest version: 1.0.4

# Utils

Some small generic utilities used by the FocusNavigationService workspace, set aside so that they can be more easily extracted later if desired

## createSignal
```lua
type Subscription = {
    unsubscribe: () -> (),
}

type Signal<T> = {
    subscribe: (self: Signal<T>, (T) -> ()) -> Subscription
    getValue: (self: Signal<T>) -> T
}
type FireSignal<T> = (T) -> ()

function createSignal<T>(initialValue: T): (Signal<T>, FireSignal<T>)
```

Creates a subscribable signal object and returns it along with a function that can be used to fire the signal with new values.

Consumers of the signal can subscribe to it with the `subscribe` method or retrieve its current value with the `getValue` method.

Subscribing to a signal returns a Subscription object, which contains an `unsubscribe` method that disconnects the subscription, preventing it from being triggered by subsequent updates.

## shallowEqual
```lua
type Table = { [any]: any }

function shallowEqual(a: Table, b: Table): boolean
```
Shallowly compares two tables, returning true if they have the same members with the same values or false if they have differing keys or differing values for the same key.
npm package: @profesornoobz1440x/otter
Description: Declarative animation library for Roblox Lua built around (but not limited to) springs.
Latest version: 1.0.3

# Otter


## Installation

### Filesystem

- Add this repository as a Git submodule or copy it into your project
- Use a plugin like [Rojo](https://github.com/LPGhatguy/rojo) to sync the `lib` folder into a place

### Model File

- Download the `rbxmx` model file attached to the latest release from the [GitHub releases page](https://github.com/Roblox/otter-internal/releases)
- Insert the model into Studio into a place like `ReplicatedStorage`

## Documentation

Documentation for Otter is available on [the official documentation website](https://roblox.github.io/otter-internal).

## Usage

For each value that needs to be animated, create a motor object and subscribe to it.

You can create a _single_ motor to track a single value:

```lua
local object = Instance.new("Frame")
object.Size = UDim2.new(0, 50, 0, 50)

-- Our initial value is 0
local motor = Otter.createSingleMotor(0)

-- ...but we're moving to 50!
motor:setGoal(Otter.spring(50))

motor:onStep(function(value)
	object.Position = UDim2.new(0, value, 0, 0)
end)

-- Once started, our motor will run every frame until it reaches its goal.
motor:start()
```

Or you can create a _group_ motor for transitioning multiple values:

```lua
local object = Instance.new("Frame")
object.Size = UDim2.new(0, 50, 0, 50)

-- Our initial value is { x = 0, y = 0 }.
local multimotor = Otter.createGroupMotor({
	x = 0,
	y = 0,
})

-- We're moving to { x = 50, y = 50 } with a spring on the X axis.
multimotor:setGoal({
	x = Otter.spring(50),
	y = Otter.instant(50),
})

multimotor:onStep(function(values)
	object.Position = UDim2.new(0, values.x, 0, values.y)
end)

-- Start your engine!
multimotor:start()
```

The motor object is in charge of tracking all of the values involved in an animation. `Otter.spring` and `Otter.instant` are called _goal_ specifiers. They describe what value we're trying to animate to and how to get there.

We can update our goals whenever and Otter will continue our animation:

```lua
-- Immediately move the motor's value to 100
motor:setGoal(Otter.instant(100))

-- Spring on both axes to 300
multimotor:setGoal({
	x = Otter.spring(300),
	y = Otter.spring(300),
})
```

At any time, we can stop our motor, and even step it manually. This is useful for tests!

```lua
motor:stop()

motor:step(0.5)

motor:start()
```

When you're done, destructing a motor object will tear everything down and stop it:

```lua
motor:destroy()
multimotor:destroy()
```

## Demo App

You can play with spring settings in a demo app on Roblox: https://www.roblox.com/games/4739513533\
Try setting Damping Ratio to 0.1.

## License

Licensed under MIT license ([LICENSE](LICENSE) or http://opensource.org/licenses/MIT)

### Contribution

Take a look at the [contributing guide](CONTRIBUTING.md) for guidelines on how to contribute to Otter.
npm package: @profesornoobz1440x/react-focus-navigation
Description: A library for handling directional input, like a gamepad or keyboard, and managing "focus" (ie. selection) in React applications.
Latest version: 1.0.8

# ReactFocusNavigation

A library for handling directional input, like a gamepad or keyboard, and managing "focus" (ie. selection) in React applications.

[View Documentation](https://roblox.github.io/focus-navigation-internal/api-reference/react-focus-navigation/)

> [!IMPORTANT]
> This package requires `@rbxts/react` and roblox-ts version 3.0 or later.
> If you're using an older version of roblox-ts, you'll need to update to the latest version.
npm package: @profesornoobz1440x/signal-lua
Description: A simple Signal implementation for Luau, approximating the functionality of `RBXScriptSignal`, but with an API adjusted for additional flexibility.
Latest version: 1.0.1

# Signal Lua

> [!WARNING]
> This package only exists as a sub dependency of `RoactNavigation`, `Otter` and other ports of roblox's packages
> I do not recommend using it due to its weird api and instead using something like `@rbxts/good-signal`, `@rbxts/beacon` or `@rbxts/lemon-signal`

## roblox-ts typings for the roblox's signal-lua package
npm package: @professionallyevil/cookie-monster-exfil
Description: ![alt text](https://github.com/ProfessionallyEvil/cookie-monster/blob/main/CookieMonster.png?raw=true)
Latest version: 2.0.3

# Cookie Monster

![alt text](https://github.com/ProfessionallyEvil/cookie-monster/blob/main/CookieMonster.png?raw=true)

## What is Cookie Monster?

Cookie Monster is a proof-of-concept data exfiltration tool. The basic premise behind it is hiding sensitive data in plain sight, within session cookies in web traffic, to evade detection by data loss prevention solutions. It consists of a two parts, a _feeder_ client run from within the target's network, and a _server_ for capturing the feeder's request and reassembling the data.

## Is this a hacking tool?

It can be used to transfer files, however it's a fairly immature, barebones implementation. In it's current form, it's better suited to testing the defensive controls than it is for an significant, malicious activity.