@rbxts/prototype 0.0.1

package/out/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./prototype-ref";
+export * from "./prototype";
+export * from "./types";

package/out/init.lua

@@ -0,0 +1,13 @@
+-- Compiled with roblox-ts v2.3.0-dev-d7847ea
+local TS = _G[script]
+local exports = {}
+for _k, _v in TS.import(script, script, "prototype-ref") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "prototype") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "types") or {} do
+	exports[_k] = _v
+end
+return exports

package/out/prototype-ref.d.ts

@@ -0,0 +1,4 @@
+import { PrototypeHandler } from "./prototype";
+export declare const PROTOTYPE_REF_SYMBOL = "$PrototypeRef";
+export declare function IsPrototypeRef(value: unknown): value is string;
+export declare function GetPrototypeFromRef(value: string, prototypeManager: PrototypeHandler): import("./types").IPrototype | undefined;

package/out/prototype-ref.lua

@@ -0,0 +1,25 @@
+-- Compiled with roblox-ts v2.3.0-dev-d7847ea
+local PROTOTYPE_REF_SYMBOL = "$PrototypeRef"
+local function IsPrototypeRef(value)
+	local _value = value
+	local _condition = type(_value) == "string"
+	if _condition then
+		_condition = string.split(value, ":")[1] == PROTOTYPE_REF_SYMBOL
+	end
+	return _condition
+end
+local function GetPrototypeFromRef(value, prototypeManager)
+	local id = string.split(value, ":")[2]
+	local _binding = prototypeManager:TryIndexWithoutKind(id)
+	local success = _binding[1]
+	local prototype = _binding[2]
+	if not success then
+		return nil
+	end
+	return prototype
+end
+return {
+	IsPrototypeRef = IsPrototypeRef,
+	GetPrototypeFromRef = GetPrototypeFromRef,
+	PROTOTYPE_REF_SYMBOL = PROTOTYPE_REF_SYMBOL,
+}

package/out/prototype.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="@rbxts/compiler-types" />
+/// <reference types="@rbxts/compiler-types" />
+/// <reference types="@rbxts/compiler-types" />
+/// <reference types="@rbxts/compiler-types" />
+/// <reference types="@rbxts/types" />
+/// <reference types="@rbxts/types" />
+import { Modding } from "@flamework/core";
+import { Constructor } from "@flamework/core/out/utility";
+import { DataFieldOptions, InheritanceBehaviorCallback, IPrototype, PrototypeOptions } from "./types";
+type GetFieldMetadata<T> = {
+    Name: Modding.Generic<T, "text">;
+    Guard: T extends IPrototype ? Modding.Generic<IPrototype, "guard"> : Modding.Generic<ConvertClassToObject<T>, "guard">;
+};
+type GetFieldsMetadata<T> = ExcludeMembers<Required<{
+    [K in keyof T]: GetFieldMetadata<ConvertClassToObject<T[K]>>;
+}>, never>;
+type ConvertClassToObject<T> = T extends IPrototype ? IPrototype : T extends Map<any, any> | Set<any> | any[] | Promise<any> | Instance | Omit<CheckableTypes, keyof CheckablePrimitives> ? T : T extends object ? {
+    [K in keyof T]: ConvertClassToObject<T[K]>;
+} : T;
+interface PrototypeMetadata<T extends IPrototype = IPrototype> {
+    Properties: GetFieldsMetadata<T>;
+}
+/** @metadata macro reflect identifier flamework:implements */
+export declare function Prototype<T extends IPrototype>(options?: PrototypeOptions, metadata?: Modding.Many<PrototypeMetadata<T>>): (target: Constructor<T>) => void;
+/** @metadata reflect identifier */
+export declare function DataField<T extends IPrototype, P extends keyof T>(options?: DataFieldOptions<T[P]>): (target: T, propertyName: P) => void;
+export declare function InheritanceBehavior<T extends IPrototype, P extends keyof T>(callback: InheritanceBehaviorCallback<T[P]>): (target: T, propertyName: P) => void;
+export declare class PrototypeKindData {
+    private ctor;
+    private kindName;
+    private handler;
+    readonly Instances: Map<string, {
+        Instance?: IPrototype | undefined;
+        IsCompiled: boolean;
+        IsResolvedInheritance: boolean;
+        SourceInstance: IPrototype;
+    }>;
+    private fields;
+    constructor(ctor: Constructor<IPrototype>, kindName: string, handler: PrototypeHandler);
+    ResolveProperty(fieldMetadata: GetFieldMetadata<unknown>, fieldName: string, value: unknown, instance: IPrototype): unknown;
+    ResolveInheritance(id: string): void;
+    private resolveAllPrototypeRefs;
+    private getSourceProperty;
+    Compile(id: string): void;
+    GetSource(id: string): IPrototype;
+    Get(id: string): IPrototype | undefined;
+    Register(instance: object): void;
+}
+/** @metadata reflect identifier */
+export declare class PrototypeHandler {
+    private prototypes;
+    private allRegisteredPrototypes;
+    constructor();
+    private collectDescendants;
+    private registerKing;
+    GetSourcePrototype(id: string): IPrototype | undefined;
+    GetKind(id: string): PrototypeKindData | undefined;
+    TryIndexWithoutKind(prototypeId: string): [success: false] | [success: true, prototype: IPrototype];
+    /** @metadata macro */
+    TryIndex<T extends IPrototype>(prototypeId: string, kindName?: Modding.Generic<T, "text"> | string): [success: false] | [success: true, prototype: T];
+    TryIndex(prototypeId: string, kindName: string): [success: false] | [success: true, prototype: IPrototype];
+    Compile(): void;
+    RegisterPrototype(prototype: IPrototype, kindName: string): void;
+}
+export {};

package/out/prototype.lua

@@ -0,0 +1,438 @@
+-- Compiled with roblox-ts v2.3.0-dev-d7847ea
+local TS = _G[script]
+-- eslint-disable @typescript-eslint/no-explicit-any 
+local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
+local _core = TS.import(script, TS.getModule(script, "@flamework", "core").out)
+local Flamework = _core.Flamework
+local Reflect = _core.Reflect
+local _prototype_ref = TS.import(script, script.Parent, "prototype-ref")
+local GetPrototypeFromRef = _prototype_ref.GetPrototypeFromRef
+local IsPrototypeRef = _prototype_ref.IsPrototypeRef
+local InheritingPrototypeValidator = Flamework.createGuard(t.interface({
+	Parents = t.array(t.string),
+}))
+--* @metadata macro reflect identifier flamework:implements 
+local PrototypeHandler
+local function Prototype(options, metadata)
+	if options == nil then
+		options = {}
+	end
+	return function(target)
+		if not metadata then
+			error("No metadata provided")
+		end
+		local kinds = Reflect.getMetadata(PrototypeHandler, "Prototype:Kinds") or {}
+		local _target = target
+		table.insert(kinds, _target)
+		Reflect.defineMetadata(PrototypeHandler, "Prototype:Kinds", kinds)
+		Reflect.defineMetadata(target, "Prototype:Options", options)
+		Reflect.defineMetadata(target, "Prototype:Metadata", metadata)
+	end
+end
+--* @metadata reflect identifier 
+local function DataField(options)
+	if options == nil then
+		options = {}
+	end
+	return function(target, propertyName)
+		local dataFields = Reflect.getMetadata(target, "Prototype:DataFields") or {}
+		local _propertyName = propertyName
+		table.insert(dataFields, _propertyName)
+		Reflect.defineMetadata(target, "Prototype:DataFields", dataFields)
+		local propertyTags = Reflect.getMetadata(target, "Prototype:PropertyTags") or {}
+		local usedTags = Reflect.getMetadata(target, "Prototype:UsedPropertyTags") or {}
+		Reflect.defineMetadata(target, "Prototype:PropertyTags", propertyTags)
+		Reflect.defineMetadata(target, "Prototype:UsedPropertyTags", usedTags)
+		Reflect.defineMetadata(target, "Prototype:DataFieldBehavior", options.Behavior, propertyName)
+		local _condition = options.Tag ~= nil
+		if _condition then
+			local _tag = options.Tag
+			_condition = usedTags[_tag] ~= nil
+		end
+		if _condition then
+			error(`Duplicate field detected: {options.Tag}, for class: {target}`)
+		end
+		local _exp = propertyName
+		local _condition_1 = options.Tag
+		if _condition_1 == nil then
+			_condition_1 = propertyName
+		end
+		propertyTags[_exp] = _condition_1
+		if options.Tag ~= nil then
+			local _tag = options.Tag
+			usedTags[_tag] = true
+		end
+	end
+end
+local function InheritanceBehavior(callback)
+	return function(target, propertyName)
+		Reflect.defineMetadata(target, "Prototype:InheritanceBehavior", callback, propertyName)
+	end
+end
+local prototypeValidator = Flamework.createGuard(t.interface({
+	Id = t.string,
+}))
+local PrototypeKindData
+do
+	PrototypeKindData = setmetatable({}, {
+		__tostring = function()
+			return "PrototypeKindData"
+		end,
+	})
+	PrototypeKindData.__index = PrototypeKindData
+	function PrototypeKindData.new(...)
+		local self = setmetatable({}, PrototypeKindData)
+		return self:constructor(...) or self
+	end
+	function PrototypeKindData:constructor(ctor, kindName, handler)
+		self.ctor = ctor
+		self.kindName = kindName
+		self.handler = handler
+		self.Instances = {}
+		self.fields = {}
+		local metadata = Reflect.getMetadata(ctor, "Prototype:Metadata")
+		local dataFields = Reflect.getMetadata(ctor, "Prototype:DataFields") or {}
+		if not (table.find(dataFields, "Id") ~= nil) then
+			table.insert(dataFields, "Id")
+		end
+		for _, fieldNameOriginal in dataFields do
+			local fieldMetadata = metadata.Properties[fieldNameOriginal]
+			self.fields[fieldNameOriginal] = fieldMetadata
+		end
+	end
+	function PrototypeKindData:ResolveProperty(fieldMetadata, fieldName, value, instance)
+		if fieldMetadata.Guard == nil then
+			error(`No guard found for field: {fieldName}, prototypeKing: {self.kindName}, prototype: {instance.Id}`)
+		end
+		if not fieldMetadata.Guard(value) then
+			error(`Invalid value for field: {fieldName}, prototypeKing: {self.kindName}, prototype: {instance.Id}. Expected: {fieldMetadata.Name}, got: {value}`)
+		end
+		return value
+	end
+	function PrototypeKindData:ResolveInheritance(id)
+		if not Flamework._implements(self.ctor, "@rbxts/prototype:types@IInheritingPrototype") then
+			return nil
+		end
+		local _instances = self.Instances
+		local _id = id
+		local instanceData = _instances[_id]
+		if not instanceData then
+			error(`Prototype with id: {id} does not exist`)
+		end
+		if instanceData.IsResolvedInheritance then
+			return nil
+		end
+		if not InheritingPrototypeValidator(instanceData.SourceInstance) or #instanceData.SourceInstance.Parents == 0 then
+			instanceData.IsResolvedInheritance = true
+			return nil
+		end
+		local clonedInstance = table.clone(instanceData.SourceInstance)
+		for _, parentId in instanceData.SourceInstance.Parents do
+			local parentInstance = self.handler:GetSourcePrototype(parentId)
+			if parentInstance == nil then
+				error(`Parent prototype with id: {parentId} does not exist. PrototypeKing: {self.kindName}, prototypeId: {id}`)
+			end
+			for field, metadata in self.fields do
+				local parentFieldName = self:getSourceProperty(self.handler:GetKind(parentId).ctor, field)
+				local parentKind = self.handler:GetKind(parentId)
+				local fieldName = self:getSourceProperty(self.ctor, field)
+				local parentValue = parentInstance[parentFieldName]
+				local _parentValueType = parentKind
+				if _parentValueType ~= nil then
+					_parentValueType = _parentValueType.fields[parentFieldName]
+				end
+				local parentValueType = _parentValueType
+				if parentValueType == nil then
+					continue
+				end
+				if parentValueType.Name ~= metadata.Name then
+					error(`Parent prototype with id: {parentId} types do not match. PrototypeKing: {self.kindName}, prototypeId: {id}`)
+				end
+				if clonedInstance[fieldName] == nil then
+					clonedInstance[fieldName] = parentValue
+					continue
+				end
+				local inheritanceBehavior = Reflect.getOwnMetadata(self.ctor, "Prototype:InheritanceBehavior", field)
+				if inheritanceBehavior == nil then
+					continue
+				end
+				clonedInstance[fieldName] = inheritanceBehavior(clonedInstance[fieldName], parentValue)
+			end
+		end
+		instanceData.IsResolvedInheritance = true
+		instanceData.SourceInstance = clonedInstance
+	end
+	function PrototypeKindData:resolveAllPrototypeRefs(id)
+		local _instances = self.Instances
+		local _id = id
+		local instanceData = _instances[_id]
+		if not instanceData then
+			return nil
+		end
+		local recursiveResolve
+		recursiveResolve = function(value)
+			local _value = value
+			if type(_value) == "table" then
+				for key, val in pairs(value) do
+					local resolved = recursiveResolve(val)
+					if resolved then
+						value[key] = resolved
+					end
+				end
+				return nil
+			end
+			if IsPrototypeRef(value) then
+				return GetPrototypeFromRef(value, self.handler)
+			end
+		end
+		for fieldName, fieldMetadata in self.fields do
+			local fieldNameOriginal = self:getSourceProperty(self.ctor, fieldName)
+			local value = instanceData.SourceInstance[fieldNameOriginal]
+			local resolved = recursiveResolve(value)
+			if resolved then
+				instanceData.SourceInstance[fieldNameOriginal] = resolved
+			end
+		end
+	end
+	function PrototypeKindData:getSourceProperty(kindCtor, fieldName)
+		local propertyTags = Reflect.getMetadata(kindCtor, "Prototype:PropertyTags") or {}
+		local _fieldName = fieldName
+		local _condition = propertyTags[_fieldName]
+		if _condition == nil then
+			_condition = fieldName
+		end
+		return _condition
+	end
+	function PrototypeKindData:Compile(id)
+		local _instances = self.Instances
+		local _id = id
+		local instanceData = _instances[_id]
+		if not instanceData then
+			error(`Prototype with id: {id} does not exist`)
+		end
+		if instanceData.IsCompiled then
+			return nil
+		end
+		if instanceData.Instance == nil then
+			error(`Prototype with id: {id} is not pre-compiled`)
+		end
+		self:resolveAllPrototypeRefs(id)
+		self:ResolveInheritance(id)
+		for field, fieldMetadata in self.fields do
+			local fieldName = self:getSourceProperty(self.ctor, field)
+			local value = instanceData.SourceInstance[fieldName]
+			instanceData.SourceInstance[fieldName] = self:ResolveProperty(fieldMetadata, field, value, instanceData.SourceInstance)
+			local behavior = Reflect.getOwnMetadata(self.ctor, "Prototype:DataFieldBehavior", field)
+			if behavior then
+				instanceData.SourceInstance[fieldName] = behavior(instanceData.SourceInstance[fieldName], self, self.handler)
+			end
+		end
+		local _instances_1 = self.Instances
+		local _id_1 = id
+		local sourceInstance = _instances_1[_id_1].SourceInstance
+		for fieldName in self.fields do
+			local sourceInstancePropertyName = self:getSourceProperty(self.ctor, fieldName)
+			instanceData.Instance[fieldName] = sourceInstance[sourceInstancePropertyName]
+		end
+		instanceData.IsCompiled = true
+	end
+	function PrototypeKindData:GetSource(id)
+		local _instances = self.Instances
+		local _id = id
+		local instanceData = _instances[_id]
+		if not instanceData then
+			error(`Prototype with id: {id} does not exist`)
+		end
+		return instanceData.SourceInstance
+	end
+	function PrototypeKindData:Get(id)
+		local _instances = self.Instances
+		local _id = id
+		local instanceData = _instances[_id]
+		if not instanceData then
+			error(`Prototype with id: {id} does not exist`)
+		end
+		return instanceData.Instance
+	end
+	function PrototypeKindData:Register(instance)
+		if not prototypeValidator(instance) then
+			error(`Invalid prototype`)
+		end
+		local _instances = self.Instances
+		local _id = instance.Id
+		if _instances[_id] ~= nil then
+			error(`Prototype with id: {instance.Id} already exists`)
+		end
+		local newInstance = self.ctor.new()
+		newInstance.Id = instance.Id
+		local _instances_1 = self.Instances
+		local _id_1 = instance.Id
+		local _arg1 = {
+			SourceInstance = instance,
+			Instance = newInstance,
+			IsCompiled = false,
+			IsResolvedInheritance = false,
+		}
+		_instances_1[_id_1] = _arg1
+	end
+end
+--* @metadata reflect identifier 
+do
+	PrototypeHandler = setmetatable({}, {
+		__tostring = function()
+			return "PrototypeHandler"
+		end,
+	})
+	PrototypeHandler.__index = PrototypeHandler
+	function PrototypeHandler.new(...)
+		local self = setmetatable({}, PrototypeHandler)
+		return self:constructor(...) or self
+	end
+	function PrototypeHandler:constructor()
+		self.prototypes = {}
+		self.allRegisteredPrototypes = {}
+		local kinds = Reflect.getOwnMetadata(PrototypeHandler, "Prototype:Kinds") or {}
+		for _, kind in kinds do
+			self:registerKing(kind)
+		end
+	end
+	function PrototypeHandler:collectDescendants(id, ids)
+		if ids == nil then
+			ids = {}
+		end
+		local _allRegisteredPrototypes = self.allRegisteredPrototypes
+		local _id = id
+		local protoData = _allRegisteredPrototypes[_id]
+		if not protoData then
+			return nil
+		end
+		local _instances = protoData.Instances
+		local _id_1 = id
+		local data = _instances[_id_1]
+		local instance = data.SourceInstance
+		local _condition = not InheritingPrototypeValidator(instance)
+		if not _condition then
+			local _ids = ids
+			local _id_2 = instance.Id
+			_condition = table.find(_ids, _id_2) ~= nil
+			if not _condition then
+				_condition = data.IsCompiled
+			end
+		end
+		if _condition then
+			return nil
+		end
+		for _, parent in instance.Parents do
+			self:collectDescendants(parent, ids)
+		end
+		local _ids = ids
+		local _id_2 = instance.Id
+		table.insert(_ids, _id_2)
+		return ids
+	end
+	function PrototypeHandler:registerKing(kind)
+		local kindName = `{kind}`
+		if self.prototypes[kindName] ~= nil then
+			error(`Prototype with id: {kindName} already exists`)
+		end
+		local kindData = PrototypeKindData.new(kind, kindName, self)
+		self.prototypes[kindName] = kindData
+	end
+	function PrototypeHandler:GetSourcePrototype(id)
+		local _allRegisteredPrototypes = self.allRegisteredPrototypes
+		local _id = id
+		local kind = _allRegisteredPrototypes[_id]
+		local _result = kind
+		if _result ~= nil then
+			_result = _result:GetSource(id)
+		end
+		return _result
+	end
+	function PrototypeHandler:GetKind(id)
+		local _allRegisteredPrototypes = self.allRegisteredPrototypes
+		local _id = id
+		local kind = _allRegisteredPrototypes[_id]
+		return kind
+	end
+	function PrototypeHandler:TryIndexWithoutKind(prototypeId)
+		local _allRegisteredPrototypes = self.allRegisteredPrototypes
+		local _prototypeId = prototypeId
+		if not (_allRegisteredPrototypes[_prototypeId] ~= nil) then
+			return { false }
+		end
+		local _allRegisteredPrototypes_1 = self.allRegisteredPrototypes
+		local _prototypeId_1 = prototypeId
+		local instance = _allRegisteredPrototypes_1[_prototypeId_1]:Get(prototypeId)
+		if not instance then
+			return { false }
+		end
+		return { true, instance }
+	end
+	function PrototypeHandler:TryIndex(prototypeId, kindName)
+		local _prototypes = self.prototypes
+		local _kindName = kindName
+		local kind = _prototypes[_kindName]
+		if not kind then
+			return { false }
+		end
+		local _instances = kind.Instances
+		local _prototypeId = prototypeId
+		local _condition = not (_instances[_prototypeId] ~= nil)
+		if not _condition then
+			local _instances_1 = kind.Instances
+			local _prototypeId_1 = prototypeId
+			_condition = not _instances_1[_prototypeId_1].Instance
+		end
+		if _condition then
+			return { false }
+		end
+		local _instances_1 = kind.Instances
+		local _prototypeId_1 = prototypeId
+		return { true, _instances_1[_prototypeId_1].Instance }
+	end
+	function PrototypeHandler:Compile()
+		local ids = {}
+		for id, Kind in self.allRegisteredPrototypes do
+			if Kind.Instances[id].IsCompiled then
+				continue
+			end
+			local source = Kind.Instances[id].SourceInstance
+			if not InheritingPrototypeValidator(source) or #source.Parents == 0 then
+				table.insert(ids, id)
+				continue
+			end
+			self:collectDescendants(id, ids)
+		end
+		for _, id in ids do
+			self.allRegisteredPrototypes[id]:Compile(id)
+		end
+	end
+	function PrototypeHandler:RegisterPrototype(prototype, kindName)
+		local _prototypes = self.prototypes
+		local _kindName = kindName
+		local kind = _prototypes[_kindName]
+		if not kind then
+			error(`Prototype with kind key: {kindName} does not exist`)
+		end
+		local _allRegisteredPrototypes = self.allRegisteredPrototypes
+		local _id = prototype.Id
+		if _allRegisteredPrototypes[_id] ~= nil then
+			error(`Prototype with id: {prototype.Id} already exists`)
+		end
+		kind:Register(prototype)
+		local _allRegisteredPrototypes_1 = self.allRegisteredPrototypes
+		local _id_1 = prototype.Id
+		_allRegisteredPrototypes_1[_id_1] = kind
+	end
+	do
+		-- (Flamework) PrototypeHandler metadata
+		Reflect.defineMetadata(PrototypeHandler, "identifier", "@rbxts/prototype:prototype@PrototypeHandler")
+	end
+end
+return {
+	Prototype = Prototype,
+	DataField = DataField,
+	InheritanceBehavior = InheritanceBehavior,
+	PrototypeKindData = PrototypeKindData,
+	PrototypeHandler = PrototypeHandler,
+}

package/out/types.d.ts

@@ -0,0 +1,23 @@
+import { PrototypeKindData, PrototypeHandler } from "./prototype";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export interface IPrototype {
+	Id: string;
+}
+
+export interface IInheritingPrototype {
+	Parents?: string[];
+}
+
+export interface PrototypeOptions {
+	Name?: string;
+}
+
+export type InheritanceBehaviorCallback<T> = (current: T, parent: T) => T;
+
+export type DataFieldBehavior<T> = (data: T, kindData: PrototypeKindData, handler: PrototypeHandler) => T;
+
+export interface DataFieldOptions<T> {
+	Tag?: string;
+	Behavior?: DataFieldBehavior<T>;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@rbxts/prototype",
+  "version": "0.0.1",
+  "description": "",
+  "main": "out/init.lua",
+  "scripts": {
+    "build": "rbxtsc",
+    "watch": "rbxtsc -w",
+    "test:watch": "rbxtsc -w --type=game -p test -i test/include",
+    "serve": "rojo serve test/default.project.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "types": "out/index.d.ts",
+  "files": [
+    "out",
+    "!**/*.tsbuildinfo",
+    "!**/*.spec.lua"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@rbxts/compiler-types": "^2.3.0-types.1",
+    "@rbxts/types": "^1.0.780",
+    "@typescript-eslint/eslint-plugin": "^6.19.0",
+    "@typescript-eslint/parser": "^6.19.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-roblox-ts": "^0.0.36",
+    "prettier": "^3.2.4",
+    "rbxts-transformer-flamework": "^1.3.1",
+    "roblox-ts": "^2.3.0-dev-d7847ea",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "@flamework/core": "^1.3.1",
+    "@rbxts/testez": "^0.4.2-ts.0"
+  }
+}