warscript 0.0.1-dev.c60b168 → 0.0.1-dev.c677d41

package/engine/synchronization.lua

@@ -0,0 +1,77 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local __TS__Promise = ____lualib.__TS__Promise
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local MINIMUM_INTEGER = ____math.MINIMUM_INTEGER
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local ____event = require("event")
+local Event = ____event.Event
+local eventInvoke = Event.invoke
+local createFrameByType = BlzCreateFrameByType
+local createTrigger = CreateTrigger
+local getOriginFrame = BlzGetOriginFrame
+local getTriggerFrameValue = BlzGetTriggerFrameValue
+local getTriggerPlayer = GetTriggerPlayer
+local frameSetMinMaxValue = BlzFrameSetMinMaxValue
+local frameSetValue = BlzFrameSetValue
+local triggerAddAction = TriggerAddAction
+local triggerRegisterFrameEvent = BlzTriggerRegisterFrameEvent
+____exports.synchronizer = function(getSyncId, getObject)
+    local queue = __TS__New(LinkedSet)
+    local socket = __TS__New(____exports.ObjectBus, getSyncId, getObject)
+    socket.event:addListener(function(_, object)
+        local ____opt_0 = queue:pop()
+        if ____opt_0 ~= nil then
+            ____opt_0(object)
+        end
+    end)
+    local function executor(____, resolve)
+        queue:add(resolve)
+    end
+    return function(player, object)
+        if player.isLocal then
+            socket:send(object)
+        end
+        return __TS__New(__TS__Promise, executor)
+    end
+end
+____exports.ObjectBus = __TS__Class()
+local ObjectBus = ____exports.ObjectBus
+ObjectBus.name = "ObjectBus"
+function ObjectBus.prototype.____constructor(self, getSyncId, getObject)
+    self.getSyncId = getSyncId
+    local syncSlider = createFrameByType(
+        "SLIDER",
+        "Synchronizer",
+        getOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0),
+        "",
+        0
+    )
+    frameSetMinMaxValue(syncSlider, MINIMUM_INTEGER, MAXIMUM_INTEGER)
+    self.syncSlider = syncSlider
+    local event = __TS__New(Event)
+    local trigger = createTrigger()
+    triggerRegisterFrameEvent(trigger, syncSlider, FRAMEEVENT_SLIDER_VALUE_CHANGED)
+    triggerAddAction(
+        trigger,
+        function()
+            eventInvoke(
+                event,
+                Player:of(getTriggerPlayer()),
+                getObject(getTriggerFrameValue())
+            )
+        end
+    )
+    self.event = event
+end
+function ObjectBus.prototype.send(self, object)
+    local syncId = object ~= nil and self.getSyncId(object) or 0
+    frameSetValue(self.syncSlider, syncId)
+end
+return ____exports

package/engine/text-tag.lua

@@ -36,6 +36,7 @@ local isUnitVisible = IsUnitVisible
 local getUnitFlyHeight = GetUnitFlyHeight
 local getUnitX = GetUnitX
 local getUnitY = GetUnitY
+local unitAlive = UnitAlive
 local DEFAULT_FONT_SIZE = 0.024
 local function applyConfiguration(textTag, configuration)
     setTextTagFadepoint(textTag, configuration.fadepoint)
@@ -141,7 +142,7 @@ __TS__SetDescriptor(
             setTextTagText(
                 ensureHandle(self),
                 self[103] or "",
-                DEFAULT_FONT_SIZE
+                fontSize
             )
             self[104] = fontSize
         end
@@ -333,7 +334,7 @@ Timer.onPeriod[1 / 64]:addListener(function()
             y,
             getUnitFlyHeight(unit) + getTerrainZ(x, y)
         )
-        if isInView and not isUnitHidden(unit) and not isUnitLoaded(unit) and isUnitVisible(unit, PLAYER_LOCAL_HANDLE) then
+        if isInView and not isUnitHidden(unit) and not isUnitLoaded(unit) and isUnitVisible(unit, PLAYER_LOCAL_HANDLE) and unitAlive(unit) then
             setTextTagPosUnit(
                 ensureHandle(textTag),
                 unit,

package/engine/unit.d.ts

@@ -19,6 +19,10 @@ import "./internal/unit/invulnerability-counter";
 import "./internal/unit/detach-missiles";
 import "./internal/unit/main-selected";
 import "./internal/unit/add-item-to-slot-init";
+import "./internal/unit/attributes";
+import "./internal/unit/fly-height";
+import "./internal/unit/scale";
+import "./internal/unit/interrupts";
 import "./internal/unit/band-aids/ancestral-spirit-cannibalize";
 export { Unit, DamagingEvent, DamageEvent } from "./internal/unit";
 export * from "./internal/unit+damage";

package/engine/unit.lua

@@ -19,6 +19,10 @@ require("engine.internal.unit.invulnerability-counter")
 require("engine.internal.unit.detach-missiles")
 require("engine.internal.unit.main-selected")
 require("engine.internal.unit.add-item-to-slot-init")
+require("engine.internal.unit.attributes")
+require("engine.internal.unit.fly-height")
+require("engine.internal.unit.scale")
+require("engine.internal.unit.interrupts")
 require("engine.internal.unit.band-aids.ancestral-spirit-cannibalize")
 do
     local ____unit = require("engine.internal.unit")

package/net/socket.lua

@@ -28,13 +28,13 @@ function Socket.prototype.____constructor(self)
     onReceive[self[0]]:addListener(function(sender, data)
         local chunks = chunksByPlayer[sender]
         if chunks ~= nil then
+            chunksByPlayer[sender] = nil
             chunks[#chunks + 1] = data
             Event.invoke(
                 self.onMessage,
                 sender,
                 tableConcat(chunks)
             )
-            chunksByPlayer[sender] = nil
         else
             Event.invoke(self.onMessage, sender, data)
         end

package/objutil/buff.lua

@@ -29,6 +29,8 @@ local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
 local ____exception = require("exception")
 local IllegalStateException = ____exception.IllegalStateException
+local ____linked_2Dmap = require("utility.linked-map")
+local LinkedMap = ____linked_2Dmap.LinkedMap
 local ____assert = _G.assert
 local ____pairs = _G.pairs
 ____exports.BuffDefinition = __TS__Class()
@@ -461,7 +463,7 @@ local buffs = setmetatable(
     {
         __mode = "k",
         __index = function(self, unit)
-            local ____table = {}
+            local ____table = __TS__New(LinkedMap)
             self[unit] = ____table
             return ____table
         end
@@ -494,7 +496,7 @@ function Buff.prototype.____constructor(self, unit, source, duration, level, pre
     end
     local constructor = self.constructor
     local instances = buffs[unit]
-    local instance = instances[constructor]
+    local instance = instances:get(constructor)
     if instance then
         instance:destroy()
         if not instance.destroyed then
@@ -507,7 +509,7 @@ function Buff.prototype.____constructor(self, unit, source, duration, level, pre
             )
         end
     end
-    instances[constructor] = self
+    instances:put(constructor, self)
     if preset then
         local unitHandle = unit.handle
         local slowPoisonMethod = not preset.positive and not preset.magic
@@ -586,13 +588,13 @@ function Buff.apply(self, ...)
     end
 end
 function Buff.getInstance(self, unit)
-    return buffs[unit][self]
+    return buffs[unit]:get(self)
 end
 function Buff.isApplied(self, unit)
-    return buffs[unit][self] ~= nil
+    return buffs[unit]:get(self) ~= nil
 end
 function Buff.ifApplied(self, unit, action)
-    local instance = buffs[unit][self]
+    local instance = buffs[unit]:get(self)
     if instance then
         ____assert(__TS__InstanceOf(instance, self))
         action(instance)
@@ -615,7 +617,7 @@ function Buff.prototype.destroy(self)
     if self.preset then
         self.unit:removeAbility(self.preset.buffId)
     end
-    buffs[self.unit][self.constructor] = nil
+    buffs[self.unit]:remove(self.constructor)
     self.destroyed = true
 end
 function Buff.prototype.onDispel(self, source)
@@ -762,7 +764,7 @@ Unit.onDamaging:addListener(function(source, target, event)
     end
 end)
 Unit.itemPickedUpEvent:addListener(function(unit, item)
-    if item.powerup and item:hasAbility(fourCC("APdi")) then
+    if item.isPowerUp and item:hasAbility(fourCC("APdi")) then
     end
 end)
 return ____exports

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package",
     "name": "warscript",
-    "version": "0.0.1-dev.c60b168",
+    "version": "0.0.1-dev.c677d41",
     "description": "A typescript library for Warcraft III using Warpack.",
     "keywords": [
         "warcraft",
@@ -24,7 +24,7 @@
         "@warscript/language-extensions": "^0.0.1",
         "@warscript/tstl-plugin": "^0.0.4",
         "lua-types": "^2.13.1",
-        "warpack": "0.0.1-dev.78d2c64"
+        "warpack": "0.0.1-dev.e490aaf"
     },
     "devDependencies": {
         "@typescript-eslint/eslint-plugin": "^8.13.0",

package/patch-lua.lua

@@ -1,5 +1,9 @@
+local error = _G.error
 local getmetatable = _G.getmetatable
 local ipairs = _G.ipairs
+local select = _G.select
+local tostring = _G.tostring
+local tableconcat = table.concat
 
 _G.ipairs = function(t)
     local metatable = getmetatable(t)
@@ -8,3 +12,14 @@ _G.ipairs = function(t)
     end
     return ipairs(t)
 end
+
+_G.assert = function(v, ...)
+    if not v then
+        local args = {}
+        for i = 1, select("#", ...) do
+            args[i] = tostring(select(i, ...))
+        end
+        error(tableconcat(args, " "))
+    end
+    return v, ...
+end

package/patch-lualib.lua

@@ -3,7 +3,7 @@ local lualib = _G.require("lualib_bundle")
 local next = _G.next
 local ____type = _G.type
 lualib.__TS__ArrayIsArray = function(value)
-    return ____type(value) == "table" and (value[1] ~= nil or ({next(value)}) == nil) and value.constructor == nil
+    return ____type(value) == "table" and (value[1] ~= nil or (next(value)) == nil) and value.constructor == nil
 end
 local __TS__SetDescriptor = lualib.__TS__SetDescriptor
 lualib.__TS__ObjectDefineProperty = function(target, key, desc)

package/utility/arrays.d.ts

@@ -5,6 +5,7 @@ export declare const joinToString: <T>(array: readonly T[], separator: string, t
 export declare const arrayOfNotNull: <T>(...elements: readonly (T | undefined | null)[]) => T[];
 export declare const array: <T, N extends number>(length: N, initialize: (index: number) => T) => TupleOf<T, N>;
 export declare const toLuaSet: <T extends AnyNotNil>(array: readonly T[]) => LuaSet<T>;
+export declare const contains: <T>(array: readonly T[], element: T) => boolean;
 export declare const forEach: <T, Args extends any[]>(array: readonly T[], consumerOrKey: ((value: T, ...args: Args) => void) | KeysOfType<T, (this: T, ...args: Args) => void>, ...args: Args) => void;
 export declare const all: {
     <T>(array: readonly T[], transform: (value: T) => boolean): boolean;

package/utility/arrays.lua

@@ -49,6 +49,14 @@ ____exports.toLuaSet = function(array)
     end
     return result
 end
+____exports.contains = function(array, element)
+    for i = 1, #array do
+        if array[i] == element then
+            return true
+        end
+    end
+    return false
+end
 ____exports.forEach = function(array, consumerOrKey, ...)
     if type(consumerOrKey) == "function" then
         for i = 1, #array do

package/utility/callback-array.d.ts

@@ -2,12 +2,16 @@
 type Callback = {
     readonly __callback: unique symbol;
 };
+export type CallbackId = number & {
+    readonly __callbackId: unique symbol;
+};
 export type CallbackArray = {
     readonly __callbackArray: unique symbol;
 } & Callback[];
 export declare const callbackArray: () => CallbackArray;
-export declare function addCallback<Args extends any[]>(this: void, array: CallbackArray, callback: (...args: Args) => unknown, ...args: Args): void;
+export declare function addCallback<Args extends any[]>(this: void, array: CallbackArray, callback: (...args: Args) => unknown, ...args: Args): CallbackId;
 export declare function clearCallbacks(this: void, array: CallbackArray): void;
+export declare function consumeCallback(this: void, array: CallbackArray, id: CallbackId): void;
 export declare function consumeCallbacks(this: void, array: CallbackArray): void;
 export declare function invokeCallbacks(this: void, array: CallbackArray): void;
 export {};

package/utility/callback-array.lua

@@ -20,8 +20,11 @@ local select = _G.select
 local tableMove = table.move
 tableUnpack = table.unpack
 ____exports.callbackArray = function() return {} end
+local function doNothing()
+end
 function ____exports.addCallback(array, callback, ...)
-    local i = array[1] or 2
+    local id = array[1] or 2
+    local i = id
     array[i] = callback
     local argsCount = select("#", ...)
     i = i + 1
@@ -31,11 +34,23 @@ function ____exports.addCallback(array, callback, ...)
         array[i] = (select(j, ...))
     end
     array[1] = i + 1
+    return id
 end
 function ____exports.clearCallbacks(array)
     local length = array[1] or 2
     tableMove(array, length, length + length - 2, 1)
 end
+function ____exports.consumeCallback(array, id)
+    local callback = array[id]
+    array[id] = doNothing
+    id = id + 1
+    local argsCount = array[id]
+    id = id + 1
+    safeCall(
+        callback,
+        tableUnpack(array, id, id + argsCount - 1)
+    )
+end
 function ____exports.consumeCallbacks(array)
     local length = array[1] or 2
     ____exports.invokeCallbacks(array)

package/utility/linked-map.d.ts

@@ -0,0 +1,26 @@
+/** @noSelfInFile */
+import { ReadonlyLinkedSet } from "./linked-set";
+type IteratorState<K extends AnyNotNil, V> = {
+    n?: K;
+    t: LuaMap<K, K>;
+    v: LuaMap<K, V>;
+};
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface LinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __linkedSet: unique symbol;
+}
+export declare class LinkedMap<K extends AnyNotNil, V> {
+    private k;
+    private v;
+    get keys(): ReadonlyLinkedSet<K>;
+    get(key: K): V | undefined;
+    getOrPut(key: K, defaultValue: (this: void) => V): V;
+    put(key: K, value: V): void;
+    remove(key: K): boolean;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    get size(): number;
+    protected __pairs(this: LinkedMap<K, V>): LuaIterator<LuaMultiReturn<[K | undefined, V | undefined]>, IteratorState<K, V>>;
+}
+export {};

package/utility/linked-map.lua

@@ -0,0 +1,66 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local function linkedMapNext(state)
+    local n = state.n
+    state.n = state.t[n]
+    return n, state.v[n]
+end
+____exports.LinkedMap = __TS__Class()
+local LinkedMap = ____exports.LinkedMap
+LinkedMap.name = "LinkedMap"
+function LinkedMap.prototype.____constructor(self)
+    self.k = __TS__New(LinkedSet)
+    self.v = {}
+end
+function LinkedMap.prototype.get(self, key)
+    return self.v[key]
+end
+function LinkedMap.prototype.getOrPut(self, key, defaultValue)
+    local value = self.v[key]
+    if value ~= nil then
+        return value
+    end
+    value = defaultValue()
+    self.k:add(key)
+    self.v[key] = value
+    return value
+end
+function LinkedMap.prototype.put(self, key, value)
+    self.k:add(key)
+    self.v[key] = value
+end
+function LinkedMap.prototype.remove(self, key)
+    if self.k:remove(key) then
+        self.v[key] = nil
+        return true
+    end
+    return false
+end
+function LinkedMap.prototype.contains(self, key)
+    return self.keys:contains(key)
+end
+function LinkedMap.prototype.__pairs(self)
+    return linkedMapNext, {n = self.k.f, t = self.k.n, v = self.v}, nil
+end
+__TS__SetDescriptor(
+    LinkedMap.prototype,
+    "keys",
+    {get = function(self)
+        return self.k
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LinkedMap.prototype,
+    "size",
+    {get = function(self)
+        return self.keys.size
+    end},
+    true
+)
+return ____exports

package/utility/linked-set.d.ts

@@ -36,6 +36,7 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     copyOf(): LinkedSet<T>;
     first(): T | undefined;
     last(): T | undefined;
+    pop(): T | undefined;
     next(key: T): T | undefined;
     previous(key: T): T | undefined;
     add(key: T): boolean;

package/utility/linked-set.lua

@@ -42,6 +42,23 @@ end
 function LinkedSet.prototype.last(self)
     return self.l
 end
+function LinkedSet.prototype.pop(self)
+    local f = self.f
+    if f == nil then
+        return nil
+    end
+    local n = self.n
+    local next = n[f]
+    n[f] = nil
+    self.f = next
+    if next ~= nil then
+        self.p[next] = nil
+    else
+        self.l = nil
+    end
+    self.s = self.s - 1
+    return f
+end
 function LinkedSet.prototype.next(self, key)
     return self.n[key]
 end
@@ -107,8 +124,9 @@ function LinkedSet.prototype.forEach(self, action, ...)
     local n = self.n
     local c = self.f
     while c ~= nil do
+        local next = n[c]
         action(c, ...)
-        c = n[c]
+        c = next
     end
 end
 function LinkedSet.prototype.toArray(self)
@@ -164,6 +182,7 @@ __TS__SetDescriptor(
     end},
     true
 )
+local emptyIteratorState = {t = {}}
 local EmptyLinkedSet = __TS__Class()
 EmptyLinkedSet.name = "EmptyLinkedSet"
 __TS__ClassExtends(EmptyLinkedSet, ____exports.LinkedSet)
@@ -173,6 +192,9 @@ function EmptyLinkedSet.prototype.add(self)
         0
     )
 end
+function EmptyLinkedSet.prototype.__pairs(self)
+    return linkedSetNext, emptyIteratorState, nil
+end
 local EMPTY_LINKED_SET = __TS__New(EmptyLinkedSet)
 ____exports.emptyLinkedSet = function()
     return EMPTY_LINKED_SET

package/utility/lua-maps.d.ts

@@ -4,6 +4,15 @@ export declare const emptyLuaMap: <K extends AnyNotNil, V>() => ReadonlyLuaMap<K
 export declare const mutableLuaMap: <K extends AnyNotNil, V>() => LuaMap<K, V>;
 export declare const mutableWeakLuaMap: <K extends AnyNotNil, V>() => LuaMap<K, V>;
 export declare const luaMapOf: <K extends AnyNotNil, V>(...pairs: Flatten<TupleOf<[K, V], 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>>) => LuaMap<K, V>;
-export declare const luaMapInvert: <K extends AnyNotNil, V extends AnyNotNil>(luaMap: LuaMap<K, V>) => LuaMap<V, K>;
-export declare const mapValues: <K extends AnyNotNil, V1, V2>(luaMap: LuaMap<K, V1>, transform: (value: V1) => V2) => LuaMap<K, V2>;
+export declare const luaMapInvert: <K extends AnyNotNil, V extends AnyNotNil>(luaMap: ReadonlyLuaMap<K, V | undefined | null>) => LuaMap<V, K>;
+export declare const toLuaMap: <K extends PropertyKey, V>(record: Record<K, V>) => LuaMap<K, V>;
+export declare const flattenKeys: <K extends AnyNotNil, V>(luaMap: ReadonlyLuaMap<readonly K[], V> | ReadonlyLuaMap<K[], V>) => LuaMap<K, V>;
+export declare const mapKeys: {
+    <K1 extends AnyNotNil, K2 extends AnyNotNil, V>(luaMap: ReadonlyLuaMap<K1, V>, transform: (value: K1) => K2): LuaMap<K2, V>;
+    <K1 extends AnyNotNil, K2 extends keyof K1, V>(luaMap: ReadonlyLuaMap<K1, V>, key: K2): K1[K2] extends AnyNotNil ? LuaMap<K1[K2], V> : never;
+};
+export declare const mapValues: {
+    <K extends AnyNotNil, V1, V2>(luaMap: ReadonlyLuaMap<K, V1>, transform: (value: V1) => V2): LuaMap<K, V2>;
+    <K extends AnyNotNil, V1, V2 extends keyof V1>(luaMap: ReadonlyLuaMap<K, V1>, key: V2): LuaMap<K, V1[V2]>;
+};
 export declare const getOrPut: <K extends AnyNotNil, V>(luaMap: LuaMap<K, V>, key: K, defaultValue: () => V) => V;

package/utility/lua-maps.lua

@@ -27,10 +27,41 @@ ____exports.luaMapInvert = function(luaMap)
     end
     return invertLuaMap
 end
+____exports.toLuaMap = function(record)
+    return record
+end
+____exports.flattenKeys = function(luaMap)
+    local result = {}
+    for keys, value in pairs(luaMap) do
+        for ____, key in ipairs(keys) do
+            result[key] = value
+        end
+    end
+    return result
+end
+____exports.mapKeys = function(luaMap, transform)
+    local result = {}
+    if type(transform) == "function" then
+        for key, value in pairs(luaMap) do
+            result[transform(key)] = value
+        end
+    else
+        for key, value in pairs(luaMap) do
+            result[key[transform]] = value
+        end
+    end
+    return result
+end
 ____exports.mapValues = function(luaMap, transform)
     local result = {}
-    for key, value in pairs(luaMap) do
-        result[key] = transform(value)
+    if type(transform) == "function" then
+        for key, value in pairs(luaMap) do
+            result[key] = transform(value)
+        end
+    else
+        for key, value in pairs(luaMap) do
+            result[key] = value[transform]
+        end
     end
     return result
 end

package/utility/records.lua

@@ -1,9 +1,28 @@
 local ____exports = {}
+local ____pairs = _G.pairs
+local tableSort = table.sort
 ____exports.invertRecord = function(record)
     local invertRecord = {}
-    for key, value in pairs(record) do
+    for key, value in ____pairs(record) do
         invertRecord[value] = key
     end
     return invertRecord
 end
+local sortedKeysInternal = {}
+local lastSortedKeysLength = 0
+---
+-- @internal For use by internal systems only.
+____exports.sortedKeysUnnested = function(record)
+    local length = 0
+    for key in ____pairs(record) do
+        length = length + 1
+        sortedKeysInternal[length] = key
+    end
+    for i = length + 1, lastSortedKeysLength do
+        sortedKeysInternal[i] = nil
+    end
+    lastSortedKeysLength = length
+    tableSort(sortedKeysInternal)
+    return sortedKeysInternal
+end
 return ____exports

package/utility/types.d.ts

@@ -37,4 +37,7 @@ export type Flatten<T extends readonly any[], A extends readonly any[] = []> = T
 export type Prohibit<T, K extends keyof any> = T & {
     [P in K]?: never;
 };
+type TupleSplit<T, N extends number, O extends readonly any[] = readonly []> = O["length"] extends N ? [O, T] : T extends readonly [infer F, ...infer R] ? TupleSplit<readonly [...R], N, readonly [...O, F]> : [O, T];
+export type TakeFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[0];
+export type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[1];
 export {};