warscript 0.0.1-dev.dd8349d → 0.0.1-dev.e147c49

package/math.lua

@@ -39,6 +39,20 @@ ____exports.floor = math.floor
 ____exports.log = math.log
 ____exports.max = math.max
 ____exports.min = math.min
+____exports.sum = function(x, ...)
+    for i = 1, select("#", ...) do
+        local number = select(i, ...)
+        x = x + number
+    end
+    return x
+end
+____exports.product = function(x, ...)
+    for i = 1, select("#", ...) do
+        local number = select(i, ...)
+        x = x * number
+    end
+    return x
+end
 --- Returns the signum function of the argument;
 -- zero if the argument is zero,
 -- 1.0 if the argument is greater than zero,

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/network.lua

@@ -8,6 +8,7 @@ local ____exports = {}
 local ____event = require("event")
 local TriggerEvent = ____event.TriggerEvent
 local ____exception = require("exception")
+local CancellationException = ____exception.CancellationException
 local IllegalArgumentException = ____exception.IllegalArgumentException
 local ____player = require("core.types.player")
 local Player = ____player.Player
@@ -86,6 +87,9 @@ function SyncOperation.prototype.____constructor(self, player, data)
     self.l = #self.d
 end
 function SyncOperation.prototype.estimate(self)
+    if self.isCanceled or not self.player.isPlaying then
+        return __TS__Promise.reject(__TS__New(CancellationException))
+    end
     if self.player.isLocal then
         sendSyncData(
             "__oh",
@@ -98,6 +102,7 @@ function SyncOperation.prototype.estimate(self)
 end
 function SyncOperation.prototype.work(self)
     if self.progress >= self.maximum then
+        syncOperationById[self.x] = nil
         return decode(concat(self.c))
     end
     self.s = packetsPerRound
@@ -116,7 +121,18 @@ function SyncOperation.prototype.work(self)
     return __TS__New(__TS__Promise, syncPromiseExecutor)
 end
 function SyncOperation.prototype.doCancel(self)
-    return false
+    if not (syncOperationById[self.x] ~= nil) then
+        return false
+    end
+    syncOperationById[self.x] = nil
+    local ____opt_1 = self.r
+    if ____opt_1 ~= nil then
+        ____opt_1(
+            self,
+            __TS__New(CancellationException)
+        )
+    end
+    return true
 end
 __TS__ObjectDefineProperty(
     SyncOperation,
@@ -178,6 +194,7 @@ SyncOperation._ = (function()
             local resolveWork = syncOperation.w
             if resolveWork then
                 if syncOperation.progress >= syncOperation.maximum then
+                    syncOperationById[id] = nil
                     resolveWork(
                         nil,
                         decode(concat(chunks))
@@ -188,6 +205,13 @@ SyncOperation._ = (function()
             end
         end
     end)
+    Player.onLeave:addListener(function(player)
+        for ____, operation in pairs(syncOperationById) do
+            if operation.player == player then
+                operation:cancel()
+            end
+        end
+    end)
 end)()
 function ____exports.synchronize(player, data)
     return __TS__New(____exports.SyncOperation, player, data):execute()

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/objutil/object.lua

@@ -153,7 +153,7 @@ end
 function ObjectDefinition.getLevelArrayFieldValue(self, level, value, values)
     return type(values) == "function" and values(level, value) or (__TS__ArrayIsArray(values[1]) and values[1] or values)
 end
-____exports.ObjectType = ObjectType or ({})
+____exports.ObjectType = ____exports.ObjectType or ({})
 ____exports.ObjectType.ABILITY = 0
 ____exports.ObjectType[____exports.ObjectType.ABILITY] = "ABILITY"
 ____exports.ObjectType.ITEM = 1

package/operation.d.ts

@@ -16,9 +16,11 @@ export { OperationContinue };
 export declare abstract class Operation<T> {
     protected constructor();
     private started;
+    private settled;
+    private canceled;
     protected progress: number;
     protected maximum: number;
-    isCanceled: boolean;
+    get isCanceled(): boolean;
     get isStarted(): boolean;
     execute(): OperationMonitor<T>;
     protected abstract estimate(): number | Promise<number>;
@@ -30,6 +32,11 @@ export declare abstract class Operation<T> {
         ...result: [success: true, result: T] | [success: false, reason?: any]
     ]>;
     get onProgress(): Event<[operation: Operation<T>]>;
+    /**
+     * Invoked with `isCanceled` already set. Should unblock any pending `estimate`/`work` promise
+     * (e.g. by rejecting it) and return whether cancellation is possible; on `false` the canceled
+     * state is reverted.
+     */
     protected abstract doCancel(): boolean;
     cancel(): boolean;
 }

package/operation.lua

@@ -22,10 +22,7 @@ OperationMonitor.name = "OperationMonitor"
 __TS__ClassExtends(OperationMonitor, __TS__Promise)
 function OperationMonitor.prototype.____constructor(self, operation, ...)
     local args = {...}
-    __TS__Promise.prototype.____constructor(
-        self,
-        table.unpack(args)
-    )
+    __TS__Promise.prototype.____constructor(self, ...)
     self.o = operation
 end
 function OperationMonitor.prototype.cancel(self)
@@ -38,9 +35,10 @@ local Operation = ____exports.Operation
 Operation.name = "Operation"
 function Operation.prototype.____constructor(self)
     self.started = false
+    self.settled = false
+    self.canceled = false
     self.progress = 0
     self.maximum = 0
-    self.isCanceled = false
 end
 function Operation.prototype.execute(self)
     if self.started then
@@ -58,6 +56,12 @@ function Operation.prototype.execute(self)
                 local result
                 local progress = self.progress
                 local ____try = __TS__AsyncAwaiter(function()
+                    if self.canceled then
+                        error(
+                            __TS__New(CancellationException),
+                            0
+                        )
+                    end
                     local maximum = __TS__Await(self:estimate())
                     self.maximum = maximum
                     if maximum ~= 0 then
@@ -68,20 +72,19 @@ function Operation.prototype.execute(self)
                     end
                     repeat
                         do
-                            if self.isCanceled then
-                                local reason = __TS__New(CancellationException)
-                                reject(nil, reason)
-                                local onFailure = ____rawget(self, "onFailure")
-                                if onFailure ~= nil then
-                                    Event.invoke(onFailure, self, reason)
-                                end
-                                local onComplete = ____rawget(self, "onComplete")
-                                if onComplete ~= nil then
-                                    Event.invoke(onComplete, self, false, reason)
-                                end
-                                return ____awaiter_resolve(nil)
+                            if self.canceled then
+                                error(
+                                    __TS__New(CancellationException),
+                                    0
+                                )
                             end
                             result = __TS__Await(self:work())
+                            if self.canceled then
+                                error(
+                                    __TS__New(CancellationException),
+                                    0
+                                )
+                            end
                             if self.progress ~= progress or self.maximum ~= maximum then
                                 progress = self.progress
                                 maximum = self.maximum
@@ -96,6 +99,7 @@ function Operation.prototype.execute(self)
                 __TS__Await(____try.catch(
                     ____try,
                     function(____, reason)
+                        self.settled = true
                         reject(nil, reason)
                         local onFailure = ____rawget(self, "onFailure")
                         if onFailure ~= nil then
@@ -108,6 +112,7 @@ function Operation.prototype.execute(self)
                         return ____awaiter_resolve(nil)
                     end
                 ))
+                self.settled = true
                 resolve(nil, result)
                 local onSuccess = ____rawget(self, "onSuccess")
                 if onSuccess ~= nil then
@@ -122,12 +127,27 @@ function Operation.prototype.execute(self)
     )
 end
 function Operation.prototype.cancel(self)
+    if self.canceled then
+        return true
+    end
+    if self.settled then
+        return false
+    end
+    self.canceled = true
     if self:doCancel() then
-        self.isCanceled = true
         return true
     end
+    self.canceled = false
     return false
 end
+__TS__SetDescriptor(
+    Operation.prototype,
+    "isCanceled",
+    {get = function(self)
+        return self.canceled
+    end},
+    true
+)
 __TS__SetDescriptor(
     Operation.prototype,
     "isStarted",

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package",
     "name": "warscript",
-    "version": "0.0.1-dev.dd8349d",
+    "version": "0.0.1-dev.e147c49",
     "description": "A typescript library for Warcraft III using Warpack.",
     "keywords": [
         "warcraft",
@@ -13,31 +13,11 @@
         "type": "git",
         "url": "git+https://github.com/rhazarian/warscript.git"
     },
-    "scripts": {
-        "clean": "rimraf dist",
-        "prebuild": "npm run clean",
-        "build": "tstl && copyfiles -u 1 \"src/**/*.d.ts\" \"src/**/*.lua\" dist && copyfiles LICENSE package.json dist",
-        "prepublishOnly": "echo You should run 'npm run publish' instead. && exit 1",
-        "publish": "npm run build && npm publish ./dist --ignore-scripts"
-    },
     "peerDependencies": {
         "@warscript/language-extensions": "^0.0.1",
-        "@warscript/tstl-plugin": "^0.0.4",
+        "@warscript/tstl-plugin": "^0.0.6",
         "lua-types": "^2.13.1",
-        "warpack": "0.0.1-dev.fa5e065"
-    },
-    "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "^8.13.0",
-        "@typescript-eslint/parser": "^8.13.0",
-        "async": "^3.2.6",
-        "copyfiles": "^2.4.1",
-        "eslint": "^9.14.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.2.1",
-        "prettier": "^3.3.3",
-        "rimraf": "^6.0.1",
-        "ts-node": "^10.9.2",
-        "tsc-watch": "^6.2.0"
+        "warpack": "github:rhazarian/warpack#release"
     },
     "publishConfig": {
         "access": "public",

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

@@ -0,0 +1,17 @@
+/** @noSelfInFile */
+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): 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

@@ -0,0 +1,61 @@
+local ____exports = {}
+local safeCall, tableUnpack
+function ____exports.invokeCallbacks(array)
+    local length = array[1] or 2
+    local i = 2
+    while i ~= length do
+        local callback = array[i]
+        i = i + 1
+        local argsCount = array[i]
+        i = i + 1
+        safeCall(
+            callback,
+            tableUnpack(array, i, i + argsCount - 1)
+        )
+        i = i + argsCount
+    end
+end
+safeCall = warpack.safeCall
+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 id = array[1] or 2
+    local i = id
+    array[i] = callback
+    local argsCount = select("#", ...)
+    i = i + 1
+    array[i] = argsCount
+    for j = 1, argsCount do
+        i = i + 1
+        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)
+    local newLength = array[1] or 2
+    tableMove(array, length, length + newLength - 3, 2)
+    array[1] = newLength - length + 2
+end
+return ____exports

package/utility/functions.d.ts

@@ -4,3 +4,10 @@ export declare const apply: {
     <T, ConsumerParameters extends any[], K extends KeysOfType<T, (...parameters: ConsumerParameters) => void>>(object: T, key: K, ...parameters: ConsumerParameters): T;
 };
 export declare const identity: <T>(value: T) => T;
+export declare const firstArgument: <T>(value: T) => T;
+export declare const secondArgument: <T>(_: unknown, value: T) => T;
+export declare const thirdArgument: <T>(_first: unknown, _second: unknown, value: T) => T;
+export declare const increment: (value: number) => number;
+export declare const or: (lhs: boolean, rhs: boolean) => boolean;
+export type Transform<T, R> = (<T, R>(value: T) => R) | KeysOfType<T, R>;
+export declare const transform: <T, R>(object: T, transform: Transform<T, R>) => R;

package/utility/functions.lua

@@ -88,4 +88,16 @@ ____exports.apply = function(object, transform, ...)
     return object
 end
 ____exports.identity = function(value) return value end
+____exports.firstArgument = ____exports.identity
+____exports.secondArgument = function(_, value) return value end
+____exports.thirdArgument = function(_first, _second, value) return value end
+____exports.increment = function(value) return value + 1 end
+____exports["or"] = function(lhs, rhs) return lhs or rhs end
+____exports.transform = function(object, transform)
+    if type(transform) == "function" then
+        return transform(object)
+    else
+        return object[transform]
+    end
+end
 return ____exports

package/utility/linked-map.d.ts

@@ -0,0 +1,35 @@
+/** @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 ReadonlyLinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly keys: ReadonlyLinkedSet<K>;
+    get(key: K): V | undefined;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    readonly size: number;
+}
+export interface LinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __linkedMap: unique symbol;
+}
+export declare class LinkedMap<K extends AnyNotNil, V> implements ReadonlyLinkedMap<K, 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 __len(): number;
+    protected __pairs(this: LinkedMap<K, V>): LuaIterator<LuaMultiReturn<[K | undefined, V | undefined]>, IteratorState<K, V>>;
+}
+export declare const emptyLinkedMap: <K extends AnyNotNil, V>() => ReadonlyLinkedMap<K, V>;
+export declare const mutableLinkedMap: <K extends AnyNotNil, V>() => LinkedMap<K, V>;
+export {};

package/utility/linked-map.lua

@@ -0,0 +1,107 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local ____exception = require("exception")
+local UnsupportedOperationException = ____exception.UnsupportedOperationException
+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.__len(self)
+    return self.keys.size
+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
+)
+local emptyIteratorState = {t = {}, v = {}}
+local EmptyLinkedMap = __TS__Class()
+EmptyLinkedMap.name = "EmptyLinkedMap"
+__TS__ClassExtends(EmptyLinkedMap, ____exports.LinkedMap)
+function EmptyLinkedMap.prototype.getOrPut(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.put(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.remove(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.__len(self)
+    return 0
+end
+function EmptyLinkedMap.prototype.__pairs(self)
+    return linkedMapNext, emptyIteratorState, nil
+end
+local EMPTY_LINKED_MAP = __TS__New(EmptyLinkedMap)
+____exports.emptyLinkedMap = function()
+    return EMPTY_LINKED_MAP
+end
+____exports.mutableLinkedMap = function()
+    return __TS__New(____exports.LinkedMap)
+end
+return ____exports