cluaupp 0.1.0

package/runtime/EzVisualz/_impl/Presets/SilverStroke.luau

@@ -0,0 +1,15 @@
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local mainGradient = TextEffects.Gradient.new(uiInstance, TextEffects.Templates.Silver.Color, 0);
+    mainGradient:SetRotation(-80, 1);
+    mainGradient:SetOffsetSpeed(speed, 1);
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, TextEffects.Templates.Silver.Color, 0);
+    strokeGradient:SetRotation(-79, 1);
+    strokeGradient:SetOffsetSpeed(speed * 0.56, 1);
+    return {
+        Effects = { mainGradient, strokeGradient, mainStroke }
+    };
+end

package/runtime/EzVisualz/_impl/Presets/SunsetStroke.luau

@@ -0,0 +1,31 @@
+local RunService = game:GetService("RunService");
+
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local mainGradient = TextEffects.Gradient.new(uiInstance, TextEffects.Templates.Sunset.Color, 0);
+    mainGradient:SetRotation(-60, 1);
+    mainGradient:SetOffsetSpeed(speed * 0.8, 1);
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, TextEffects.Templates.Sunset.Color, 0);
+    strokeGradient:SetRotation(60, 1);
+    strokeGradient:SetOffsetSpeed(-speed * 0.6, 1);
+
+    local Rotation = 0;
+    local Connection;
+    Connection = RunService.Heartbeat:Connect(function(dt)
+        if (not mainGradient.Instance or mainGradient.Instance.Parent == nil) then
+            Connection:Disconnect();
+            return;
+        end;
+        Rotation = Rotation + speed * dt * 20;
+        mainGradient:SetRotation(-60 + math.sin(Rotation * 0.1) * 20, 0.2);
+        strokeGradient:SetRotation(60 - math.sin(Rotation * 0.1) * 20, 0.2);
+    end);
+
+    return {
+        Effects = { mainGradient, strokeGradient, mainStroke },
+        Connections = { Connection }
+    };
+end

package/runtime/EzVisualz/_impl/Presets/WaveStroke.luau

@@ -0,0 +1,33 @@
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local actualColor: Color3 = Color3.new(1, 1, 1);
+    if customColor then
+        if typeof(customColor) == "ColorSequence" then
+            actualColor = customColor.Keypoints[1].Value;
+        else
+            actualColor = customColor;
+        end;
+    end;
+    local colorSequence = ColorSequence.new({
+        ColorSequenceKeypoint.new(0, actualColor),
+        ColorSequenceKeypoint.new(0.5, actualColor),
+        ColorSequenceKeypoint.new(1, actualColor)
+    });
+
+    local transparencySequence = NumberSequence.new({
+        NumberSequenceKeypoint.new(0, 0),
+        NumberSequenceKeypoint.new(0.25, 1),
+        NumberSequenceKeypoint.new(0.5, 1),
+        NumberSequenceKeypoint.new(0.75, 1),
+        NumberSequenceKeypoint.new(1, 0)
+    });
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, colorSequence, transparencySequence);
+    strokeGradient:SetOffsetSpeed(speed, 1);
+    strokeGradient:SetTransparencyOffsetSpeed(speed * 0.9, 1);
+    return {
+        Effects = { strokeGradient, mainStroke }
+    };
+end

package/runtime/EzVisualz/_impl/Presets/Zebra.luau

@@ -0,0 +1,21 @@
+local TextEffects = require(script.Parent.Parent);
+
+return function(uiInstance: GuiObject, speed: number, size: number, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, useScaledSize: boolean?)
+    local mainGradient = TextEffects.Gradient.new(uiInstance, TextEffects.Templates.Zebra.Color, 0);
+    mainGradient:SetOffsetSpeed(speed, 1);
+    mainGradient:SetRotation(90, 1);
+
+    local mainStroke = TextEffects.Stroke.new(uiInstance, size, nil, nil, useScaledSize);
+
+    local strokeGradient = TextEffects.Gradient.new(mainStroke.Instance, TextEffects.Templates.Zebra.Color, 0);
+    strokeGradient:SetOffset(0.5, 1);
+    strokeGradient:SetRotation(90, 1);
+
+    task.delay(0.1, function()
+        strokeGradient:SetOffsetSpeed(speed, 1);
+    end);
+
+    return {
+        Effects = { mainGradient, strokeGradient, mainStroke }
+    };
+end

package/runtime/EzVisualz/_impl/Presets/init.luau

@@ -0,0 +1,9 @@
+local Modules = script:GetDescendants();
+local SubModules = {};
+
+for _, module in Modules do
+    if (not module:IsA("ModuleScript")) then continue end;
+    SubModules[module.Name] = require(module);
+end
+
+return SubModules;

package/runtime/EzVisualz/_impl/Stroke.luau

@@ -0,0 +1,167 @@
+local RunService = game:GetService("RunService");
+local SmartAssert = require(script.Parent.Util);
+
+-- Fingeroo was here ( ͡° ͜ʖ ͡°)
+
+export type Stroke<T...> = {
+	UIInstance: GuiObject,
+	Instance: UIStroke,
+	IsPaused: boolean,
+	UseScaledSize: boolean,
+	Color: Color3,
+	ColorTarget: Color3,
+	ColorAcceleration: number,
+	Transparency: number,
+	TransparencyTarget: number,
+	TransparencyAcceleration: number,
+	Size: number,
+	SizeTarget: number,
+	SizeAcceleration: number,
+	Connection: RBXScriptConnection,
+	IsText: boolean,
+
+	Pause: (self: Stroke<T...>) -> nil,
+	Resume: (self: Stroke<T...>) -> nil,
+	SetSize: (self: Stroke<T...>, size: number, acceleration: number) -> nil,
+	SetTransparency: (self: Stroke<T...>, transparency: number, acceleration: number) -> nil,
+	SetColor: (self: Stroke<T...>, color: Color3, acceleration: number) -> nil,
+	SetScaledSize: (self: Stroke<T...>, useScaledSize: boolean) -> nil,
+	Destroy: (self: Stroke<T...>) -> nil,
+};
+
+local Stroke = {};
+Stroke.__index = Stroke;
+
+function Stroke.new<T...>(uiInstance: GuiObject | UIStroke, size: number, color: Color3?, transparency: number?, useScaledSize: boolean?): Stroke<T...>
+	SmartAssert(uiInstance ~= nil, "UIInstance not provided");
+	SmartAssert(uiInstance:IsA("GuiObject") or uiInstance:IsA("UIStroke"), "UIInstance is not a GuiObject or UIStroke");
+	SmartAssert(size ~= nil, "Size not provided");
+	SmartAssert(typeof(size) == "number", "Size is not a number");
+	if (color) then
+		SmartAssert(typeof(color) == "Color3", "Color is not a Color3");
+	end;
+	if (transparency) then
+		SmartAssert(typeof(transparency) == "number", "Transparency is not a number");
+	end;
+	if (useScaledSize ~= nil) then
+		SmartAssert(typeof(useScaledSize) == "boolean", "useScaledSize is not a boolean");
+	end;
+
+	local self = {};
+
+	self.UIInstance = uiInstance;
+	self.Instance = uiInstance:FindFirstChildWhichIsA("UIStroke") or Instance.new("UIStroke");
+	self.UseScaledSize = useScaledSize == true;
+	if (useScaledSize == true) then
+		self.Instance.StrokeSizingMode = Enum.StrokeSizingMode.ScaledSize;
+	end;
+	self.IsPaused = false;
+
+	self.Color = color or Color3.new(1, 1, 1);
+	self.ColorTarget = color or Color3.new(1, 1, 1);
+	self.ColorAcceleration = 1;
+
+	self.Transparency = transparency or 0;
+	self.TransparencyTarget = transparency or 0;
+	self.TransparencyAcceleration = 1;
+
+	if self.UseScaledSize and math.abs(size) > 1 then
+		size = size / 100;
+	end
+
+	self.Size = size;
+	self.SizeTarget = size;
+	self.SizeAcceleration = 1;
+	self.Connection = nil;
+	self.IsText = false;
+
+	if (uiInstance:IsA("TextLabel") or uiInstance:IsA("TextBox") or uiInstance:IsA("TextButton")) then
+		self.IsText = true;
+	end;
+
+	self.Instance.Parent = self.UIInstance;
+
+	self.Connection = RunService.Heartbeat:Connect(function(dt)
+		if (self.IsPaused) then
+			return;
+		end;
+
+		if (not self.UIInstance or self.UIInstance.Parent == nil) then
+			self:Destroy();
+			return;
+		end;
+
+		self.Color = self.Color:Lerp(self.ColorTarget, self.ColorAcceleration * dt * 10);
+		self.Size = self.Size + ((self.SizeTarget - self.Size) * self.SizeAcceleration * dt * 10);
+		self.Transparency = self.Transparency + ((self.TransparencyTarget - self.Transparency) * self.TransparencyAcceleration * dt * 10);
+
+		self.Instance.Transparency = self.Transparency;
+		self.Instance.Color = self.Color;
+		self.Instance.Thickness = self.Size;
+	end);
+
+	return setmetatable(self, Stroke);
+end
+
+function Stroke:SetSize(size: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(size) == "number", "Size isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	-- What I thought of doing here is when someone uses ScaledSize and they pass a number greater than 1, we divide it by 100 to get the percentage.
+	if self.UseScaledSize and math.abs(size) > 1 then
+		size = size / 100;
+	end
+
+	self.SizeTarget = size;
+	self.SizeAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Stroke:SetTransparency(transparency: number, acceleration: number)
+	-- Accepts a number as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(transparency) == "number", "Transparency isn't a number");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.TransparencyTarget = transparency;
+	self.TransparencyAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Stroke:SetColor(color: Color3, acceleration: number)
+	-- Accepts a Color3 as the first argument and a number as the second argument.
+	-- Values below 0 or above 1 for the acceleration argument do not make sense.
+	SmartAssert(typeof(color) == "Color3", "Color isn't a Color3");
+	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
+
+	self.ColorTarget = color;
+	self.ColorAcceleration = math.clamp(acceleration, 0, 1);
+end
+
+function Stroke:SetScaledSize(useScaledSize: boolean)
+	SmartAssert(typeof(useScaledSize) == "boolean", "useScaledSize isn't a boolean");
+
+	if (useScaledSize) then
+		self.Instance.StrokeSizingMode = Enum.StrokeSizingMode.ScaledSize;
+	else
+		self.Instance.StrokeSizingMode = Enum.StrokeSizingMode.FixedSize;
+	end;
+end
+
+function Stroke:Pause()
+	self.IsPaused = true;
+end
+
+function Stroke:Resume()
+	self.IsPaused = false;
+end
+
+function Stroke:Destroy()
+	self.Connection:Disconnect();
+	if (self.Instance) then
+		self.Instance:Destroy();
+		self.Instance = nil;
+	end;
+end
+
+return table.freeze(Stroke);

package/runtime/EzVisualz/_impl/Util.luau

@@ -0,0 +1,7 @@
+local function SmartAssert(condition: boolean, message: string)
+	if (not condition) then
+		error(message, 2);
+	end;
+end
+
+return SmartAssert :: (boolean, string) -> ();

package/runtime/EzVisualz/_impl/init.luau

@@ -0,0 +1,319 @@
+local DefaultPresets = script.Presets;
+local DefaultTemplates = script.GradientTemplates;
+
+-- Imports
+local SmartAssert = require(script.Util);
+
+export type Effect<T...> = {
+	UIInstance: GuiObject,
+	EffectObjects: { Instance },
+	SavedObjects: { Instance },
+	Speed: number,
+	Size: number,
+	IsPaused: boolean,
+
+	Pause: (self: Effect<T...>) -> nil,
+	Resume: (self: Effect<T...>) -> nil,
+	Destroy: (self: Effect<T...>) -> nil,
+};
+
+local Effect = {};
+Effect.Gradient = require(script.Gradient);
+Effect.Stroke = require(script.Stroke);
+Effect.Dropshadow = require(script.Dropshadow);
+
+Effect.__index = Effect;
+Effect.CurrentEffects = {};
+
+local CustomPresetsFolder: Folder? = nil;
+local CustomTemplatesFolder: Folder? = nil;
+
+-- Cached merged presets and templates
+local MergedPresets: { [string]: ModuleScript }? = nil;
+local MergedTemplates: { [string]: UIGradient }? = nil;
+
+local VisibleOrEnabledChart = {
+	["GuiObject"] = "Visible",
+	["ScreenGui"] = "Enabled",
+	["BillboardGui"] = "Enabled",
+	["SurfaceGui"] = "Enabled",
+};
+
+local function _loadPresetsFromFolder(folder: Folder): { [string]: ModuleScript }
+	local presets = {};
+	for _, module in folder:GetDescendants() do
+		if module:IsA("ModuleScript") then
+			presets[module.Name] = module;
+		end;
+	end;
+	return presets;
+end
+
+local function _loadTemplatesFromFolder(folder: Folder): { [string]: UIGradient }
+	local templates = {};
+	for _, module in folder:GetDescendants() do
+		if module:IsA("ModuleScript") then
+			local templateFunction = require(module);
+			if typeof(templateFunction) == "function" then
+				templates[module.Name] = templateFunction();
+			end;
+		end;
+	end;
+	return templates;
+end
+
+local function _getMergedPresets(): { [string]: ModuleScript }
+	if MergedPresets then
+		return MergedPresets;
+	end;
+
+	local merged = {};
+
+	-- Load default presets first
+	for name, module in pairs(_loadPresetsFromFolder(DefaultPresets)) do
+		merged[name] = module;
+	end;
+
+	-- Override with custom presets if they exist
+	if CustomPresetsFolder then
+		for name, module in pairs(_loadPresetsFromFolder(CustomPresetsFolder)) do
+			merged[name] = module;
+		end;
+	end;
+
+	MergedPresets = merged;
+	return merged;
+end
+
+local function _getMergedTemplates(): { [string]: UIGradient }
+	if MergedTemplates then
+		return MergedTemplates;
+	end;
+
+	local merged = {};
+
+	-- Load default templates first
+	for name, template in pairs(_loadTemplatesFromFolder(DefaultTemplates)) do
+		merged[name] = template;
+	end;
+
+	-- Override with custom templates if they exist
+	if CustomTemplatesFolder then
+		for name, template in pairs(_loadTemplatesFromFolder(CustomTemplatesFolder)) do
+			merged[name] = template;
+		end;
+	end;
+
+	MergedTemplates = merged;
+	return merged;
+end
+
+local function _findPreset(presetName: string): ModuleScript?
+	local presets = _getMergedPresets();
+	return presets[presetName];
+end
+
+local function ValidateIsPreset(presetName: string): boolean
+	return _findPreset(presetName) ~= nil;
+end
+
+--[[
+	Function to set custom folders for presets and templates.
+	This allows users to add their own presets/templates without forking the module.
+
+	Custom presets/templates will override default ones with the same name.
+
+	Example usage:
+		local EasyVisuals = require(path.to.EasyVisuals)
+
+		-- Create custom folders in your game
+		local CustomPresets = Instance.new("Folder")
+		CustomPresets.Name = "CustomPresets"
+		CustomPresets.Parent = workspace -- or wherever you want
+
+		local CustomTemplates = Instance.new("Folder")
+		CustomTemplates.Name = "CustomTemplates"
+		CustomTemplates.Parent = workspace
+
+		-- Add your custom preset modules to CustomPresets folder
+		-- Add your custom template modules to CustomTemplates folder
+
+		-- Hook up the custom folders
+		EasyVisuals.SetCustomFolders(CustomPresets, CustomTemplates)
+
+		-- Now you can use your custom presets!
+		local effect = EasyVisuals.new(textLabel, "MyCustomPreset", 0.5, 3)
+
+	@param customPresets Folder? - Optional folder containing custom preset ModuleScripts
+	@param customTemplates Folder? - Optional folder containing custom template ModuleScripts
+]]
+function Effect.SetCustomFolders(customPresets: Folder?, customTemplates: Folder?)
+	if customPresets then
+		SmartAssert(customPresets:IsA("Folder"), "customPresets must be a Folder");
+	end;
+	if customTemplates then
+		SmartAssert(customTemplates:IsA("Folder"), "customTemplates must be a Folder");
+	end;
+
+	CustomPresetsFolder = customPresets;
+	CustomTemplatesFolder = customTemplates;
+
+	-- Clear cache to force reload
+	MergedPresets = nil;
+	MergedTemplates = nil;
+
+	Effect.Templates = _getMergedTemplates();
+end
+
+Effect.Templates = _getMergedTemplates();
+
+function Effect.new<T...>(uiInstance: GuiObject, effectType: string, speed: number?, size: number?, saveInstanceObjects: boolean?, customColor: ColorSequence | Color3?, customTransparency: NumberSequence | number?, resumesOnVisible: boolean?, useScaledSize: boolean?): Effect<T...>
+	SmartAssert(uiInstance ~= nil, "UIInstance not provided");
+	SmartAssert(effectType ~= nil, "EffectType not provided");
+	SmartAssert(uiInstance:IsA("GuiObject"), "UIInstance is not a GuiObject");
+	SmartAssert(typeof(effectType) == "string", "effectType is not a string");
+	SmartAssert(ValidateIsPreset(effectType), "effectType is not a valid preset");
+	if (speed) then
+		SmartAssert(typeof(speed) == "number", "speed is not a number");
+	end;
+	if (size) then
+		SmartAssert(typeof(size) == "number", "size is not a number");
+	end;
+	if (customColor) then
+		SmartAssert(typeof(customColor) == "ColorSequence" or typeof(customColor) == "Color3", "customColor is not a ColorSequence or Color3");
+	end;
+	if (customTransparency) then
+		SmartAssert(typeof(customTransparency) == "NumberSequence" or typeof(customTransparency) == "number", "customTransparency is not a NumberSequence or number");
+	end;
+	if (useScaledSize ~= nil) then
+		SmartAssert(typeof(useScaledSize) == "boolean", "useScaledSize is not a boolean");
+	end;
+
+	local self = {};
+
+	self.IsPaused = false;
+	self.Diagnostic = "DIAGNOSTIC VALUE";
+	self.UIInstance = uiInstance;
+	self.ResumesOnShown = resumesOnVisible == nil and true or resumesOnVisible;
+	self.EffectObjects = {};
+	self.SavedObjects = {};
+	self.Connections = {};
+	self.Speed = speed or 0.007;
+	self.Size = size or 1;
+
+	-- Climb up the parent tree of the UIInstance and attach GetPropertyChangedSignal to the Visible property of each object
+	-- If the Visible property changes to false, destroy the effect
+	local function RecursiveAncestryChanged(Object: Instance)
+		if (not Object) then
+			return;
+		end;
+
+		-- If the object is a PlayerGui or Workspace, stop climbing
+		if (Object:IsA("PlayerGui") or Object:IsA("Workspace")) then
+			return;
+		end;
+
+		-- If the object is a ScreenGui, BillboardGui, or SurfaceGui, check if it's enabled
+		local IsVisibleOrEnabled = VisibleOrEnabledChart[Object.ClassName];
+		if (not IsVisibleOrEnabled) then
+			RecursiveAncestryChanged(Object.Parent);
+			return;
+		end;
+
+		table.insert(self.Connections, Object:GetPropertyChangedSignal(IsVisibleOrEnabled):Connect(function()
+			self.IsPaused = not Object[IsVisibleOrEnabled];
+			if (self.IsPaused) then
+				self:Pause();
+			else
+				if (self.ResumesOnShown) then
+					self:Resume();
+				end;
+			end;
+		end));
+
+		RecursiveAncestryChanged(Object.Parent);
+	end;
+	RecursiveAncestryChanged(uiInstance);
+
+	if (saveInstanceObjects) then
+		for _, Object in uiInstance:GetChildren() do
+			if (Object:IsA("UIStroke") or Object:IsA("UIGradient")) then
+				table.insert(self.SavedObjects, Object);
+				Object.Parent = nil;
+			end;
+		end;
+	end;
+
+	local PresetModule = _findPreset(effectType);
+	SmartAssert(PresetModule ~= nil, "Preset '" .. effectType .. "' not found");
+	local Preset = require(PresetModule);
+	local Objects = Preset(uiInstance, self.Speed, self.Size, customColor, customTransparency, useScaledSize);
+
+	if (Objects["Connections"]) then
+		for _, Connection in Objects["Connections"] do
+			table.insert(self.Connections, Connection);
+		end;
+	end;
+	if (Objects["Effects"]) then
+		for _, ObjectEffect in Objects["Effects"] do
+			table.insert(self.EffectObjects, ObjectEffect);
+		end;
+	end;
+
+	self.Connection = uiInstance.AncestryChanged:Connect(function()
+		if (not uiInstance:IsDescendantOf(game)) then
+			self:Destroy();
+		end;
+	end);
+
+	return setmetatable(self, Effect);
+end
+
+function Effect:Pause()
+	-- print("Effect paused");
+	for _, Object in self.EffectObjects do
+		if (Object.Pause) then
+			Object:Pause();
+		end;
+	end;
+end
+
+function Effect:Resume()
+	-- print("Effect resumed");
+	for _, Object in self.EffectObjects do
+		if (Object.Resume) then
+			Object:Resume();
+		end;
+	end;
+end
+
+function Effect:Destroy()
+	for _, Object in self.SavedObjects do
+		Object.Parent = self.UIInstance;
+	end;
+	for _, Connection in self.Connections do
+		Connection:Disconnect();
+	end;
+
+	table.clear(self.SavedObjects);
+	table.clear(self.Connections);
+
+	for _, Object in self.EffectObjects do
+		if (not Object.Destroy) then
+			continue;
+		end;
+		Object:Destroy();
+	end;
+
+	self.Connection:Disconnect();
+end
+
+function Effect:Play()
+	self:Resume();
+end
+
+function Effect:Stop()
+	self:Pause();
+end
+
+return Effect;

package/runtime/EzVisualz/_impl/wally.lock

@@ -0,0 +1,8 @@
+# This file is automatically @generated by Wally.
+# It is not intended for manual editing.
+registry = "test"
+
+[[package]]
+name = "arxkdev/ezvisualz"
+version = "0.0.5"
+dependencies = []

package/runtime/EzVisualz/_impl/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "arxkdev/ezvisualz"
+description = "ezVisualz is a powerful library designed to enhance the animation of UI elements using UIGradients. It provides a wide range of presets out of the box and offers an easy-to-use experience for creating captivating visual effects."
+version = "1.2.0"
+license = "MIT"
+authors = ["Arxk (https://github.com/arxkdev)"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

package/runtime/EzVisualz/init.luau

@@ -0,0 +1,9 @@
+--!strict
+-- Cluaupp EzVisualz — typed border over arxkdev/ezVisualz (_impl).
+
+local Impl = require(script._impl)
+
+export type Effect<T...> = Impl.Effect<T...>
+export type EzVisualz = typeof(Impl)
+
+return Impl

package/runtime/EzVisualz/wally.lock

@@ -0,0 +1,8 @@
+# This file is automatically @generated by Wally.
+# It is not intended for manual editing.
+registry = "test"
+
+[[package]]
+name = "arxkdev/ezvisualz"
+version = "0.0.5"
+dependencies = []

package/runtime/EzVisualz/wally.toml

@@ -0,0 +1,8 @@
+[package]
+name = "arxkdev/ezvisualz"
+description = "ezVisualz is a powerful library designed to enhance the animation of UI elements using UIGradients. It provides a wide range of presets out of the box and offers an easy-to-use experience for creating captivating visual effects."
+version = "1.2.0"
+license = "MIT"
+authors = ["Arxk (https://github.com/arxkdev)"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"

package/runtime/FormatNumber/LICENSE.md

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2022, Blockzez
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.