warscript 0.0.1-dev.404878c

package/engine/standard/pathing-textures.d.ts

@@ -0,0 +1,6 @@
+/** @noSelfInFile */
+export declare const PATHING_TEXTURE_NONE_PATH = "none";
+export declare const PATHING_TEXTURE_2X2_PATH = "PathTextures\\2x2Default.tga";
+export declare const PATHING_TEXTURE_2X4_PATH = "PathTextures\\2x4Default.tga";
+export declare const PATHING_TEXTURE_4X2_PATH = "PathTextures\\4x2Default.tga";
+export declare const PATHING_TEXTURE_4X4_PATH = "PathTextures\\4x4Default.tga";

package/engine/standard/pathing-textures.lua

@@ -0,0 +1,7 @@
+local ____exports = {}
+____exports.PATHING_TEXTURE_NONE_PATH = "none"
+____exports.PATHING_TEXTURE_2X2_PATH = "PathTextures\\2x2Default.tga"
+____exports.PATHING_TEXTURE_2X4_PATH = "PathTextures\\2x4Default.tga"
+____exports.PATHING_TEXTURE_4X2_PATH = "PathTextures\\4x2Default.tga"
+____exports.PATHING_TEXTURE_4X4_PATH = "PathTextures\\4x4Default.tga"
+return ____exports

package/engine/text-tag.d.ts

@@ -0,0 +1,25 @@
+/** @noSelfInFile */
+import { Color } from "../core/types/color";
+export type TextTagPreset = {
+    fadepoint: number;
+    lifespan: number;
+    offsetX: number;
+    offsetY: number;
+    offsetZ: number;
+    velocityX: number;
+    velocityY: number;
+    color: Color;
+};
+export declare class TextTag {
+    private readonly handle;
+    private constructor();
+    static BASE: Readonly<TextTagPreset>;
+    static BASH: Readonly<TextTagPreset>;
+    static CRITICAL_STRIKE: Readonly<TextTagPreset>;
+    static GOLD_BOUNTY: Readonly<TextTagPreset>;
+    static LUMBER_BOUNTY: Readonly<TextTagPreset>;
+    static MANA_BURN: Readonly<TextTagPreset>;
+    static MISS: Readonly<TextTagPreset>;
+    static SHADOW_STRIKE: Readonly<TextTagPreset>;
+    static flash(configuration: Readonly<TextTagPreset>, text: string, x: number, y: number, z?: number): void;
+}

package/engine/text-tag.lua

@@ -0,0 +1,109 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ObjectAssign = ____lualib.__TS__ObjectAssign
+local ____exports = {}
+local ____color = require("core.types.color")
+local Color = ____color.Color
+local createTextTag = CreateTextTag
+local destroyTextTag = DestroyTextTag
+local setTextTagText = SetTextTagText
+local setTextTagPos = SetTextTagPos
+local setTextTagPosUnit = SetTextTagPosUnit
+local setTextTagColor = SetTextTagColor
+local setTextTagVelocity = SetTextTagVelocity
+local setTextTagVisibility = SetTextTagVisibility
+local setTextTagSuspended = SetTextTagSuspended
+local setTextTagPermanent = SetTextTagPermanent
+local setTextTagAge = SetTextTagAge
+local setTextTagLifespan = SetTextTagLifespan
+local setTextTagFadepoint = SetTextTagFadepoint
+local DEFAULT_FONT_SIZE = 0.024
+____exports.TextTag = __TS__Class()
+local TextTag = ____exports.TextTag
+TextTag.name = "TextTag"
+function TextTag.prototype.____constructor(self, handle)
+    self.handle = handle
+end
+function TextTag.flash(self, configuration, text, x, y, z)
+    local textTag = createTextTag()
+    setTextTagText(textTag, text, DEFAULT_FONT_SIZE)
+    setTextTagPos(textTag, x + configuration.offsetX, y + configuration.offsetY, (z or 0) + configuration.offsetZ)
+    setTextTagFadepoint(textTag, configuration.fadepoint)
+    setTextTagLifespan(textTag, configuration.lifespan)
+    local color = configuration.color
+    setTextTagColor(
+        textTag,
+        color.r,
+        color.g,
+        color.b,
+        color.a
+    )
+    setTextTagVelocity(textTag, configuration.velocityX, configuration.velocityY)
+    setTextTagPermanent(textTag, false)
+    setTextTagVisibility(textTag, true)
+end
+TextTag.BASE = {
+    fadepoint = 2,
+    lifespan = 3,
+    offsetX = 0,
+    offsetY = 0,
+    offsetZ = 0,
+    velocityX = 0,
+    velocityY = 0.03,
+    color = Color.white
+}
+TextTag.BASH = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {
+        color = Color:of(0, 0, 255),
+        velocityY = 0.04,
+        lifespan = 5
+    }
+)
+TextTag.CRITICAL_STRIKE = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {
+        color = Color:of(255, 0, 0),
+        velocityY = 0.04,
+        lifespan = 5
+    }
+)
+TextTag.GOLD_BOUNTY = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {color = Color:of(255, 220, 0)}
+)
+TextTag.LUMBER_BOUNTY = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {color = Color:of(0, 200, 80)}
+)
+TextTag.MANA_BURN = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {
+        color = Color:of(82, 82, 255),
+        velocityY = 0.04,
+        lifespan = 5
+    }
+)
+TextTag.MISS = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {
+        fadepoint = 1,
+        color = Color:of(255, 0, 0)
+    }
+)
+TextTag.SHADOW_STRIKE = __TS__ObjectAssign(
+    {},
+    ____exports.TextTag.BASE,
+    {
+        color = Color:of(160, 255, 0),
+        velocityY = 0.04,
+        lifespan = 5
+    }
+)
+return ____exports

package/engine/unit.d.ts

@@ -0,0 +1,20 @@
+/** @noSelfInFile */
+import "./internal/unit";
+import "./internal/unit/ability";
+import "./internal/unit/allowed-targets";
+import "./internal/unit/buff";
+import "./internal/unit/expiration-timer";
+import "./internal/unit+ability";
+import "./internal/unit+damage";
+import "./internal/unit+rally";
+import "./internal/unit+spellSteal";
+import "./internal/unit+transport";
+import "./internal/unit/summon-event";
+import "./internal/unit/missile";
+import "./internal/unit-missile-launch";
+import "./internal/unit/ghost-counter";
+import "./internal/unit/invulnerability-counter";
+import "./internal/unit/band-aids/ancestral-spirit-cannibalize";
+export { Unit, DamagingEvent, DamageEvent } from "./internal/unit";
+export * from "./internal/unit+damage";
+export * from "./internal/unit+rally";

package/engine/unit.lua

@@ -0,0 +1,31 @@
+local ____exports = {}
+require("engine.internal.unit")
+require("engine.internal.unit.ability")
+require("engine.internal.unit.allowed-targets")
+require("engine.internal.unit.buff")
+require("engine.internal.unit.expiration-timer")
+require("engine.internal.unit+ability")
+require("engine.internal.unit+damage")
+require("engine.internal.unit+rally")
+require("engine.internal.unit+spellSteal")
+require("engine.internal.unit+transport")
+require("engine.internal.unit.summon-event")
+require("engine.internal.unit.missile")
+require("engine.internal.unit-missile-launch")
+require("engine.internal.unit.ghost-counter")
+require("engine.internal.unit.invulnerability-counter")
+require("engine.internal.unit.band-aids.ancestral-spirit-cannibalize")
+do
+    local ____unit = require("engine.internal.unit")
+    local Unit = ____unit.Unit
+    ____exports.Unit = Unit
+end
+do
+    local ____export = require("engine.internal.unit+damage")
+    for ____exportKey, ____exportValue in pairs(____export) do
+        if ____exportKey ~= "default" then
+            ____exports[____exportKey] = ____exportValue
+        end
+    end
+end
+return ____exports

package/event.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+export type EventListener<T extends any[]> = (...args: T) => void;
+export declare const enum EventListenerPriority {
+    LOWEST = 0,
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3,
+    HIGHEST = 4
+}
+export declare class Event<T extends any[] = []> {
+    protected listeners: EventListener<any>[];
+    protected priorityByListener: LuaMap<EventListener<any>, EventListenerPriority>;
+    addListener(listener: EventListener<T>): void;
+    addListener(priority: EventListenerPriority, listener: EventListener<T>): void;
+    protected addListenerInternal(priority: EventListenerPriority, listener: EventListener<T>): boolean;
+    removeListener(listener: EventListener<T>): boolean;
+    static invoke<T extends any[]>(this: void, event: Event<T>, ...args: T): void;
+}
+export declare class InitializingEvent<T extends any[] = [], Data = void> extends Event<T> {
+    #private;
+    private readonly initialize;
+    private readonly deinitialize?;
+    constructor(initialize: (this: void, event: InitializingEvent<T, Data>) => Data, deinitialize?: ((this: void, data: Data) => void) | undefined);
+    protected addListenerInternal(priority: EventListenerPriority, listener: EventListener<T>): boolean;
+    removeListener(callback: EventListener<T>): boolean;
+    destroy(): void;
+}
+declare const IgnoreEvent: unique symbol;
+type IgnoreEvent = typeof IgnoreEvent;
+export { IgnoreEvent };
+export declare class TriggerEvent<T extends any[] = []> extends InitializingEvent<T, jtrigger | undefined> {
+    constructor(r: (trigger: jtrigger) => void, c: () => LuaMultiReturn<T | [IgnoreEvent]>);
+}
+export type EventParameters<T> = T extends Event<infer P> ? P : never;
+export type EventDispatchTable<EventType extends Event<any>, KeyType extends number = number> = {
+    readonly [key in KeyType]: EventType;
+};
+export type DispatchingEvent<P extends any[], T extends Event<P> = Event<P>, S extends Event<P> = Event<P>> = T & EventDispatchTable<S>;
+export declare const createDispatchingEvent: {
+    <T extends Event<any>, S extends Event<EventParameters<T>>>(underlyingEvent: T, extractKey: (...args: EventParameters<T>) => number, ...createEvent: [...(Event<any> extends S ? [(() => S)?] : [() => S])]): DispatchingEvent<EventParameters<T>, T>;
+};
+export declare class DependentInitializingEvent<T extends any[], R extends any[]> extends InitializingEvent<R, EventListener<T>> {
+    constructor(underlyingEvent: Event<T>, priority: EventListenerPriority, collector: (...args: T) => LuaMultiReturn<[false] | [true, ...R]>);
+}
+export declare class EventParametersCaptor<T extends any[]> {
+    private readonly event;
+    private invoked?;
+    private constructor();
+    getFirstParameters(): LuaMultiReturn<[] | T>;
+    getLastParameters(): LuaMultiReturn<[] | T>;
+    static create<T extends any[]>(event: Event<T>): EventParametersCaptor<T>;
+}

package/event.lua

@@ -0,0 +1,269 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Symbol = ____lualib.__TS__Symbol
+local Symbol = ____lualib.Symbol
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local condition = Condition
+local createTrigger = CreateTrigger
+local triggerAddCondition = TriggerAddCondition
+local triggerClearConditions = TriggerClearConditions
+local destroyTrigger = DestroyTrigger
+local safeCall = warpack.safeCall
+local next = _G.next
+____exports.Event = __TS__Class()
+local Event = ____exports.Event
+Event.name = "Event"
+function Event.prototype.____constructor(self)
+    self.listeners = {}
+    self.priorityByListener = {}
+end
+function Event.prototype.addListener(self, priority, listener)
+    if listener == nil then
+        listener = priority
+        priority = 2
+    end
+    self:addListenerInternal(priority, listener)
+end
+function Event.prototype.addListenerInternal(self, priority, listener)
+    local priorityByListener = self.priorityByListener
+    local previousPriority = priorityByListener[listener]
+    if previousPriority == nil then
+        local listeners = self.listeners
+        local length = #listeners
+        listeners[length + 1] = listener
+        priorityByListener[listener] = priority
+        for i = length, 1, -1 do
+            local otherListener = listeners[i]
+            local otherPriority = priorityByListener[otherListener]
+            if priority > otherPriority then
+                listeners[i] = listener
+                listeners[i + 1] = otherListener
+            else
+                return true
+            end
+        end
+        return true
+    end
+    return false
+end
+function Event.prototype.removeListener(self, listener)
+    if self.priorityByListener[listener] ~= nil then
+        self.priorityByListener[listener] = nil
+        local listeners = self.listeners
+        for i = 1, #listeners do
+            if listeners[i] == listener then
+                for j = i, #listeners do
+                    listeners[j] = listeners[j + 1]
+                end
+                return true
+            end
+        end
+    end
+    return false
+end
+function Event.invoke(event, ...)
+    local listeners = event.listeners
+    for i = 1, #listeners do
+        safeCall(listeners[i], ...)
+    end
+end
+____exports.InitializingEvent = __TS__Class()
+local InitializingEvent = ____exports.InitializingEvent
+InitializingEvent.name = "InitializingEvent"
+__TS__ClassExtends(InitializingEvent, ____exports.Event)
+function InitializingEvent.prototype.____constructor(self, initialize, deinitialize)
+    InitializingEvent.____super.prototype.____constructor(self)
+    self.initialize = initialize
+    self.deinitialize = deinitialize
+end
+function InitializingEvent.prototype.addListenerInternal(self, priority, listener)
+    if self["#destroyed"] then
+        return false
+    end
+    local success = InitializingEvent.____super.prototype.addListenerInternal(self, priority, listener)
+    if success and #self.listeners == 1 then
+        self["#data"] = self.initialize(self)
+    end
+    return success
+end
+function InitializingEvent.prototype.removeListener(self, callback)
+    if InitializingEvent.____super.prototype.removeListener(self, callback) then
+        if self.deinitialize and (next(self.listeners)) == nil then
+            self.deinitialize(self["#data"])
+            self["#data"] = nil
+        end
+        return true
+    end
+    return false
+end
+function InitializingEvent.prototype.destroy(self)
+    self["#destroyed"] = true
+    if #self.listeners > 0 then
+        self.listeners = {}
+        self.priorityByListener = {}
+        if self.deinitialize then
+            self.deinitialize(self["#data"])
+            self["#data"] = nil
+        end
+    end
+end
+local invoke = ____exports.Event.invoke
+local IgnoreEvent = __TS__Symbol()
+____exports.IgnoreEvent = IgnoreEvent
+local function invokeEventIfNotIgnored(event, arg, ...)
+    if arg ~= IgnoreEvent then
+        invoke(event, arg, ...)
+    end
+end
+____exports.TriggerEvent = __TS__Class()
+local TriggerEvent = ____exports.TriggerEvent
+TriggerEvent.name = "TriggerEvent"
+__TS__ClassExtends(TriggerEvent, ____exports.InitializingEvent)
+function TriggerEvent.prototype.____constructor(self, r, c)
+    TriggerEvent.____super.prototype.____constructor(
+        self,
+        function(event)
+            local trigger = createTrigger()
+            triggerAddCondition(
+                trigger,
+                condition(function()
+                    invokeEventIfNotIgnored(
+                        event,
+                        c()
+                    )
+                end)
+            )
+            r(trigger)
+            return trigger
+        end,
+        function(trigger)
+            if trigger then
+                triggerClearConditions(trigger)
+                destroyTrigger(trigger)
+            end
+        end
+    )
+end
+____exports.createDispatchingEvent = function(underlyingEvent, extractKey, createEvent)
+    local actualCreateEvent = createEvent or (function() return __TS__New(____exports.Event) end)
+    local initialized = false
+    return setmetatable(
+        {},
+        {
+            __index = function(self, id)
+                if type(id) ~= "number" then
+                    return underlyingEvent[id]
+                end
+                if not initialized then
+                    local invoke = ____exports.Event.invoke
+                    underlyingEvent:addListener(function(...)
+                        local key = extractKey(...)
+                        local event = rawget(self, key)
+                        if event then
+                            invoke(event, ...)
+                        end
+                    end)
+                    initialized = true
+                end
+                local event = actualCreateEvent()
+                rawset(self, id, event)
+                return event
+            end,
+            __newindex = underlyingEvent
+        }
+    )
+end
+local function invokeEventIfNeeded(event, needed, ...)
+    if needed then
+        ____exports.Event.invoke(event, ...)
+    end
+end
+____exports.DependentInitializingEvent = __TS__Class()
+local DependentInitializingEvent = ____exports.DependentInitializingEvent
+DependentInitializingEvent.name = "DependentInitializingEvent"
+__TS__ClassExtends(DependentInitializingEvent, ____exports.InitializingEvent)
+function DependentInitializingEvent.prototype.____constructor(self, underlyingEvent, priority, collector)
+    DependentInitializingEvent.____super.prototype.____constructor(
+        self,
+        function(event)
+            local function listener(...)
+                invokeEventIfNeeded(
+                    event,
+                    collector(...)
+                )
+            end
+            underlyingEvent:addListener(priority, listener)
+            return listener
+        end,
+        function(listener)
+            underlyingEvent:removeListener(listener)
+        end
+    )
+end
+local tableUnpack = table.unpack
+local captorsToProcessByEvent = {}
+local lastParametersByEvent = {}
+____exports.EventParametersCaptor = __TS__Class()
+local EventParametersCaptor = ____exports.EventParametersCaptor
+EventParametersCaptor.name = "EventParametersCaptor"
+function EventParametersCaptor.prototype.____constructor(self, event)
+    self.event = event
+    local captorsToProcess = captorsToProcessByEvent[event]
+    if captorsToProcess == nil then
+        captorsToProcess = setmetatable({}, {__mode = "k"})
+        captorsToProcessByEvent[event] = captorsToProcess
+        event:addListener(
+            4,
+            function(...)
+                local lastParameters = lastParametersByEvent[event]
+                if lastParameters == nil then
+                    lastParameters = {n = 0}
+                    lastParametersByEvent[event] = lastParameters
+                end
+                local argsN = select("#", ...)
+                for captor in pairs(captorsToProcess) do
+                    if not captor.invoked then
+                        for i = 1, argsN do
+                            local arg = select(i, ...)
+                            captor[i] = arg
+                        end
+                        captor.invoked = true
+                    end
+                end
+                if (next(captorsToProcess)) ~= nil then
+                    captorsToProcess = setmetatable({}, {__mode = "k"})
+                    captorsToProcessByEvent[event] = captorsToProcess
+                end
+                for i = 1, argsN do
+                    local arg = select(i, ...)
+                    lastParameters[i] = arg
+                end
+                for i = argsN, lastParameters.n do
+                    lastParameters[i] = nil
+                end
+                lastParameters.n = argsN
+            end
+        )
+    end
+    captorsToProcess[self] = true
+end
+function EventParametersCaptor.prototype.getFirstParameters(self)
+    if self.invoked then
+        return tableUnpack(self)
+    else
+        return
+    end
+end
+function EventParametersCaptor.prototype.getLastParameters(self)
+    if self.invoked then
+        return tableUnpack(lastParametersByEvent[self.event])
+    else
+        return
+    end
+end
+function EventParametersCaptor.create(self, event)
+    return __TS__New(____exports.EventParametersCaptor, event)
+end
+return ____exports

package/exception.d.ts

@@ -0,0 +1,17 @@
+/** @noSelfInFile */
+export declare class Exception {
+    readonly message?: string;
+    readonly cause?: Exception;
+    readonly stackTrace: string[];
+    constructor();
+    constructor(message: string);
+    constructor(message: string, cause: Exception);
+    constructor(cause: Exception);
+    toString(): string;
+}
+export declare class IllegalArgumentException extends Exception {
+}
+export declare class IllegalStateException extends Exception {
+}
+export declare class CancellationException extends Exception {
+}

package/exception.lua

@@ -0,0 +1,53 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____error = _G.error
+local xpcall = _G.xpcall
+local substring = string.sub
+local stackTrace
+local i
+local ok
+local function handler(stackTraceElement)
+    if stackTraceElement ~= "" then
+        stackTrace[i] = substring(stackTraceElement, 1, -3)
+        i = i + 1
+    else
+        ok = false
+    end
+end
+____exports.Exception = __TS__Class()
+local Exception = ____exports.Exception
+Exception.name = "Exception"
+function Exception.prototype.____constructor(self, messageOrCause, cause)
+    if type(messageOrCause) == "table" then
+        self.message = tostring(messageOrCause)
+        self.cause = messageOrCause
+    else
+        self.message = messageOrCause
+        self.cause = cause
+    end
+    stackTrace = {}
+    i = 1
+    ok = true
+    while ok do
+        xpcall(____error, handler, "", 3 + i)
+    end
+    self.stackTrace = stackTrace
+end
+function Exception.prototype.__tostring(self)
+    return (self.constructor.name .. ": ") .. tostring(self.message)
+end
+____exports.IllegalArgumentException = __TS__Class()
+local IllegalArgumentException = ____exports.IllegalArgumentException
+IllegalArgumentException.name = "IllegalArgumentException"
+__TS__ClassExtends(IllegalArgumentException, ____exports.Exception)
+____exports.IllegalStateException = __TS__Class()
+local IllegalStateException = ____exports.IllegalStateException
+IllegalStateException.name = "IllegalStateException"
+__TS__ClassExtends(IllegalStateException, ____exports.Exception)
+____exports.CancellationException = __TS__Class()
+local CancellationException = ____exports.CancellationException
+CancellationException.name = "CancellationException"
+__TS__ClassExtends(CancellationException, ____exports.Exception)
+return ____exports

package/file.d.ts

@@ -0,0 +1,4 @@
+/** @noSelfInFile */
+export declare function read(filename: string): string | undefined;
+export declare function writeRaw(filename: string, ...args: string[]): void;
+export declare function write(filename: string, content: string): void;

package/file.lua

@@ -0,0 +1,42 @@
+local ____exports = {}
+local preloader = Preloader
+local abilityId = util.s2id("ANcl")
+local maxPreloadSize = 259
+local noDataMarker = "NO_DATA_PRESENT"
+function ____exports.read(filename)
+    BlzSetAbilityIcon(abilityId, noDataMarker)
+    preloader(filename)
+    local data = BlzGetAbilityIcon(abilityId)
+    if data == noDataMarker then
+        return nil
+    else
+        return data
+    end
+end
+local function escapePreload(input)
+    return string.format("\")\n%s\n//", input)
+end
+local prelude = "\n//! beginusercode\nlocal o={}\nlocal i=1\nPreload=function(s)o[i]=s;i=i+1 end\nPreloadEnd=function()end\n//! endusercode\n"
+local postlude = string.format("\n//! beginusercode\nBlzSetAbilityIcon(%s, table.concat(o))\n//! endusercode\n", abilityId)
+function ____exports.writeRaw(filename, ...)
+    local args = {...}
+    PreloadGenClear()
+    PreloadGenStart()
+    for ____, content in ipairs(args) do
+        for ____, part in ipairs(string.partition(content, maxPreloadSize)) do
+            Preload(part)
+        end
+    end
+    PreloadGenEnd(filename)
+end
+function ____exports.write(filename, content)
+    PreloadGenClear()
+    PreloadGenStart()
+    Preload(escapePreload(prelude))
+    for ____, part in ipairs(string.partition(content, maxPreloadSize)) do
+        Preload(part)
+    end
+    Preload(escapePreload(postlude))
+    PreloadGenEnd(filename)
+end
+return ____exports

package/global/math.d.ts

@@ -0,0 +1,21 @@
+/** @noSelfInFile */
+
+/** @noResolution */
+declare namespace math {
+    /** Clamps the given value between the given minimum and maximum values. Returns the given value if it is within the min and max range. */
+    function clamp(v: number, min: number, max: number): number
+    /** Returns the sign of v. Return value is 1 when v is positive or zero, -1 when v is negative. */
+    function sign(v: number): number
+    /** Linearly interpolates between a and b by t. */
+    function lerp(a: number, b: number, t: number): number
+}
+
+/** @noResolution */
+declare namespace table {
+    function bininsert<T>(list: T[], value: T, comp?: (a: T, b: T) => boolean): void
+    function binsearch<T>(
+        list: T[],
+        value: T,
+        comp?: (a: T, b: T) => boolean
+    ): LuaMultiReturn<[number, number] | [undefined]>
+}