@codebolt/litegraph 0.0.1

package/dist/subgraph/SubgraphInputNode.d.ts

@@ -0,0 +1,33 @@
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphOutput } from './SubgraphOutput';
+import { LinkConnector } from '../canvas/LinkConnector';
+import { CanvasPointer } from '../CanvasPointer';
+import { DefaultConnectionColors, INodeInputSlot, INodeOutputSlot, ISlotType, Positionable } from '../interfaces';
+import { LGraphNode, NodeId } from '../LGraphNode';
+import { RerouteId } from '../Reroute';
+import { CanvasPointerEvent } from '../types/events';
+import { NodeLike } from '../types/NodeLike';
+import { LLink } from '../LLink';
+import { EmptySubgraphInput } from './EmptySubgraphInput';
+import { SubgraphIONodeBase } from './SubgraphIONodeBase';
+export declare class SubgraphInputNode extends SubgraphIONodeBase<SubgraphInput> implements Positionable {
+    readonly id: NodeId;
+    readonly emptySlot: EmptySubgraphInput;
+    get slots(): SubgraphInput[];
+    get allSlots(): SubgraphInput[];
+    get slotAnchorX(): number;
+    onPointerDown(e: CanvasPointerEvent, pointer: CanvasPointer, linkConnector: LinkConnector): void;
+    /** @inheritdoc */
+    renameSlot(slot: SubgraphInput, name: string): void;
+    /** @inheritdoc */
+    removeSlot(slot: SubgraphInput): void;
+    canConnectTo(inputNode: NodeLike, input: INodeInputSlot, fromSlot: SubgraphInput): boolean;
+    connectSlots(fromSlot: SubgraphInput, inputNode: LGraphNode, input: INodeInputSlot, afterRerouteId: RerouteId | undefined): LLink;
+    connectByType(slot: number, target_node: LGraphNode, target_slotType: ISlotType, optsIn?: {
+        afterRerouteId?: RerouteId;
+    }): LLink | undefined;
+    findOutputSlot(name: string): SubgraphInput | undefined;
+    findOutputByType(type: ISlotType): SubgraphInput | undefined;
+    _disconnectNodeInput(node: LGraphNode, input: INodeInputSlot, link: LLink | undefined): void;
+    drawProtected(ctx: CanvasRenderingContext2D, colorContext: DefaultConnectionColors, fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput, editorAlpha?: number): void;
+}

package/dist/subgraph/SubgraphNode.d.ts

@@ -0,0 +1,73 @@
+import { ISubgraphInput } from '../interfaces';
+import { BaseLGraph, LGraph } from '../LGraph';
+import { GraphOrSubgraph, Subgraph } from './Subgraph';
+import { ExportedSubgraphInstance } from '../types/serialisation';
+import { IBaseWidget } from '../types/widgets';
+import { UUID } from '../utils/uuid';
+import { LGraphButton } from '../LGraphButton';
+import { LGraphCanvas } from '../LGraphCanvas';
+import { LGraphNode } from '../LGraphNode';
+import { INodeInputSlot, ISlotType, NodeId } from '../litegraph';
+import { LLink, ResolvedConnection } from '../LLink';
+import { ExecutableLGraphNode, ExecutionId } from './ExecutableNodeDTO';
+/**
+ * An instance of a {@link Subgraph}, displayed as a node on the containing (parent) graph.
+ */
+export declare class SubgraphNode extends LGraphNode implements BaseLGraph {
+    #private;
+    /** The (sub)graph that contains this subgraph instance. */
+    readonly graph: GraphOrSubgraph;
+    /** The definition of this subgraph; how its nodes are configured, etc. */
+    readonly subgraph: Subgraph;
+    inputs: (INodeInputSlot & Partial<ISubgraphInput>)[];
+    readonly type: UUID;
+    readonly isVirtualNode: true;
+    get rootGraph(): LGraph;
+    get displayType(): string;
+    isSubgraphNode(): this is SubgraphNode;
+    widgets: IBaseWidget[];
+    constructor(
+    /** The (sub)graph that contains this subgraph instance. */
+    graph: GraphOrSubgraph, 
+    /** The definition of this subgraph; how its nodes are configured, etc. */
+    subgraph: Subgraph, instanceData: ExportedSubgraphInstance);
+    onTitleButtonClick(button: LGraphButton, canvas: LGraphCanvas): void;
+    configure(info: ExportedSubgraphInstance): void;
+    _internalConfigureAfterSlots(): void;
+    /**
+     * Ensures the subgraph slot is in the params before adding the input as normal.
+     * @param name The name of the input slot.
+     * @param type The type of the input slot.
+     * @param inputProperties Properties that are directly assigned to the created input. Default: a new, empty object.
+     * @returns The new input slot.
+     * @remarks Assertion is required to instantiate empty generic POJO.
+     */
+    addInput<TInput extends Partial<ISubgraphInput>>(name: string, type: ISlotType, inputProperties?: TInput): INodeInputSlot & TInput;
+    getInputLink(slot: number): LLink | null;
+    /**
+     * Finds the internal links connected to the given input slot inside the subgraph, and resolves the nodes / slots.
+     * @param slot The slot index
+     * @returns The resolved connections, or undefined if no input node is found.
+     * @remarks This is used to resolve the input links when dragging a link from a subgraph input slot.
+     */
+    resolveSubgraphInputLinks(slot: number): ResolvedConnection[];
+    /**
+     * Finds the internal link connected to the given output slot inside the subgraph, and resolves the nodes / slots.
+     * @param slot The slot index
+     * @returns The output node if found, otherwise undefined.
+     */
+    resolveSubgraphOutputLink(slot: number): ResolvedConnection | undefined;
+    /** @internal Used to flatten the subgraph before execution. */
+    getInnerNodes(
+    /** The set of computed node DTOs for this execution. */
+    executableNodes: Map<ExecutionId, ExecutableLGraphNode>, 
+    /** The path of subgraph node IDs. */
+    subgraphNodePath?: readonly NodeId[], 
+    /** Internal recursion param. The list of nodes to add to. */
+    nodes?: ExecutableLGraphNode[], 
+    /** Internal recursion param. The set of visited nodes. */
+    visited?: Set<SubgraphNode>): ExecutableLGraphNode[];
+    removeWidgetByName(name: string): void;
+    ensureWidgetRemoved(widget: IBaseWidget): void;
+    onRemoved(): void;
+}

package/dist/subgraph/SubgraphOutput.d.ts

@@ -0,0 +1,30 @@
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphOutputNode } from './SubgraphOutputNode';
+import { INodeInputSlot, INodeOutputSlot, Point, ReadOnlyRect } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { RerouteId } from '../Reroute';
+import { LLink } from '../LLink';
+import { SubgraphSlot } from './SubgraphSlotBase';
+/**
+ * An output "slot" from a subgraph to a parent graph.
+ *
+ * IMPORTANT: A subgraph "output" is both an output AND an input.  It creates an extra link connection point between
+ * a parent graph and a subgraph, so is conceptually similar to a reroute.
+ *
+ * This can be a little confusing, but is easier to visualise when imagining editing a subgraph.
+ * You have "Subgraph Outputs", because they go from inside the subgraph and out, but links to them come from "node outputs".
+ *
+ * Functionally, however, when editing a subgraph, that "subgraph output" is the "target" or "input side" of a link.
+ */
+export declare class SubgraphOutput extends SubgraphSlot {
+    parent: SubgraphOutputNode;
+    connect(slot: INodeOutputSlot, node: LGraphNode, afterRerouteId?: RerouteId): LLink | undefined;
+    get labelPos(): Point;
+    arrange(rect: ReadOnlyRect): void;
+    /**
+     * Checks if this slot is a valid target for a connection from the given slot.
+     * For SubgraphOutput (which acts as an input inside the subgraph),
+     * the fromSlot should be an output slot.
+     */
+    isValidTarget(fromSlot: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput): boolean;
+}

package/dist/subgraph/SubgraphOutputNode.d.ts

@@ -0,0 +1,31 @@
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphOutput } from './SubgraphOutput';
+import { LinkConnector } from '../canvas/LinkConnector';
+import { CanvasPointer } from '../CanvasPointer';
+import { DefaultConnectionColors, INodeInputSlot, INodeOutputSlot, ISlotType, Positionable } from '../interfaces';
+import { LGraphNode, NodeId } from '../LGraphNode';
+import { LLink } from '../LLink';
+import { RerouteId } from '../Reroute';
+import { CanvasPointerEvent } from '../types/events';
+import { NodeLike } from '../types/NodeLike';
+import { SubgraphIO } from '../types/serialisation';
+import { EmptySubgraphOutput } from './EmptySubgraphOutput';
+import { SubgraphIONodeBase } from './SubgraphIONodeBase';
+export declare class SubgraphOutputNode extends SubgraphIONodeBase<SubgraphOutput> implements Positionable {
+    readonly id: NodeId;
+    readonly emptySlot: EmptySubgraphOutput;
+    get slots(): SubgraphOutput[];
+    get allSlots(): SubgraphOutput[];
+    get slotAnchorX(): number;
+    onPointerDown(e: CanvasPointerEvent, pointer: CanvasPointer, linkConnector: LinkConnector): void;
+    /** @inheritdoc */
+    renameSlot(slot: SubgraphOutput, name: string): void;
+    /** @inheritdoc */
+    removeSlot(slot: SubgraphOutput): void;
+    canConnectTo(outputNode: NodeLike, fromSlot: SubgraphOutput, output: INodeOutputSlot | SubgraphIO): boolean;
+    connectByTypeOutput(slot: number, target_node: LGraphNode, target_slotType: ISlotType, optsIn?: {
+        afterRerouteId?: RerouteId;
+    }): LLink | undefined;
+    findInputByType(type: ISlotType): SubgraphOutput | undefined;
+    drawProtected(ctx: CanvasRenderingContext2D, colorContext: DefaultConnectionColors, fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput, editorAlpha?: number): void;
+}

package/dist/subgraph/SubgraphSlotBase.d.ts

@@ -0,0 +1,61 @@
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphInputNode } from './SubgraphInputNode';
+import { SubgraphOutput } from './SubgraphOutput';
+import { SubgraphOutputNode } from './SubgraphOutputNode';
+import { DefaultConnectionColors, Hoverable, INodeInputSlot, INodeOutputSlot, Point, ReadOnlyRect, ReadOnlySize } from '../interfaces';
+import { LGraphNode } from '../LGraphNode';
+import { LinkId, LLink } from '../LLink';
+import { RerouteId } from '../Reroute';
+import { CanvasPointerEvent } from '../types/events';
+import { Serialisable, SubgraphIO } from '../types/serialisation';
+import { ConstrainedSize } from '../infrastructure/ConstrainedSize';
+import { Rectangle } from '../infrastructure/Rectangle';
+import { SlotBase } from '../node/SlotBase';
+import { UUID } from '../utils/uuid';
+export interface SubgraphSlotDrawOptions {
+    ctx: CanvasRenderingContext2D;
+    colorContext: DefaultConnectionColors;
+    lowQuality?: boolean;
+    fromSlot?: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput;
+    editorAlpha?: number;
+}
+/** Shared base class for the slots used on Subgraph . */
+export declare abstract class SubgraphSlot extends SlotBase implements SubgraphIO, Hoverable, Serialisable<SubgraphIO> {
+    #private;
+    static get defaultHeight(): number;
+    readonly measurement: ConstrainedSize;
+    readonly id: UUID;
+    readonly parent: SubgraphInputNode | SubgraphOutputNode;
+    type: string;
+    readonly linkIds: LinkId[];
+    readonly boundingRect: Rectangle;
+    get pos(): Point;
+    set pos(value: Point);
+    /** Whether this slot is connected to another slot. */
+    get isConnected(): boolean;
+    /** The display name of this slot. */
+    get displayName(): string;
+    abstract get labelPos(): Point;
+    constructor(slot: SubgraphIO, parent: SubgraphInputNode | SubgraphOutputNode);
+    isPointerOver: boolean;
+    containsPoint(point: Point): boolean;
+    onPointerMove(e: CanvasPointerEvent): void;
+    getLinks(): LLink[];
+    decrementSlots(inputsOrOutputs: "inputs" | "outputs"): void;
+    measure(): ReadOnlySize;
+    abstract arrange(rect: ReadOnlyRect): void;
+    abstract connect(slot: INodeInputSlot | INodeOutputSlot, node: LGraphNode, afterRerouteId?: RerouteId): LLink | undefined;
+    /**
+     * Disconnects all links connected to this slot.
+     */
+    disconnect(): void;
+    /**
+     * Checks if this slot is a valid target for a connection from the given slot.
+     * @param fromSlot The slot that is being dragged to connect to this slot.
+     * @returns true if the connection is valid, false otherwise.
+     */
+    abstract isValidTarget(fromSlot: INodeInputSlot | INodeOutputSlot | SubgraphInput | SubgraphOutput): boolean;
+    /** @remarks Leaves the context dirty. */
+    draw({ ctx, colorContext, lowQuality, fromSlot, editorAlpha }: SubgraphSlotDrawOptions): void;
+    asSerialisable(): SubgraphIO;
+}

package/dist/subgraph/subgraphUtils.d.ts

@@ -0,0 +1,77 @@
+import { GraphOrSubgraph } from './Subgraph';
+import { SubgraphInput } from './SubgraphInput';
+import { SubgraphOutput } from './SubgraphOutput';
+import { INodeInputSlot, INodeOutputSlot, Positionable } from '../interfaces';
+import { LGraph } from '../LGraph';
+import { ISerialisedNode, SerialisableLLink, SubgraphIO } from '../types/serialisation';
+import { UUID } from '../utils/uuid';
+import { LGraphGroup } from '../LGraphGroup';
+import { LGraphNode } from '../LGraphNode';
+import { LLink, ResolvedConnection } from '../LLink';
+import { Reroute } from '../Reroute';
+import { SubgraphInputNode } from './SubgraphInputNode';
+import { SubgraphOutputNode } from './SubgraphOutputNode';
+export interface FilteredItems {
+    nodes: Set<LGraphNode>;
+    reroutes: Set<Reroute>;
+    groups: Set<LGraphGroup>;
+    subgraphInputNodes: Set<SubgraphInputNode>;
+    subgraphOutputNodes: Set<SubgraphOutputNode>;
+    unknown: Set<Positionable>;
+}
+export declare function splitPositionables(items: Iterable<Positionable>): FilteredItems;
+interface BoundaryLinks {
+    boundaryLinks: LLink[];
+    boundaryFloatingLinks: LLink[];
+    internalLinks: LLink[];
+    boundaryInputLinks: LLink[];
+    boundaryOutputLinks: LLink[];
+}
+export declare function getBoundaryLinks(graph: LGraph, items: Set<Positionable>): BoundaryLinks;
+export declare function multiClone(nodes: Iterable<LGraphNode>): ISerialisedNode[];
+/**
+ * Groups resolved connections by output object. If the output is nullish, the connection will be in its own group.
+ * @param resolvedConnections The resolved connections to group
+ * @returns A map of grouped connections.
+ */
+export declare function groupResolvedByOutput(resolvedConnections: ResolvedConnection[]): Map<SubgraphIO | INodeOutputSlot | object, ResolvedConnection[]>;
+export declare function mapSubgraphInputsAndLinks(resolvedInputLinks: ResolvedConnection[], links: SerialisableLLink[]): SubgraphIO[];
+/**
+ * Clones the output slots, and updates existing links, when converting items to a subgraph.
+ * @param resolvedOutputLinks The resolved output links.
+ * @param links The links to add to the subgraph.
+ * @returns The subgraph output slots.
+ */
+export declare function mapSubgraphOutputsAndLinks(resolvedOutputLinks: ResolvedConnection[], links: SerialisableLLink[]): SubgraphIO[];
+/**
+ * Collects all subgraph IDs used directly in a single graph (non-recursive).
+ * @param graph The graph to check for subgraph nodes
+ * @returns Set of subgraph IDs used in this graph
+ */
+export declare function getDirectSubgraphIds(graph: GraphOrSubgraph): Set<UUID>;
+/**
+ * Collects all subgraph IDs referenced in a graph hierarchy using BFS.
+ * @param rootGraph The graph to start from
+ * @param subgraphRegistry Map of all available subgraphs
+ * @returns Set of all subgraph IDs found
+ */
+export declare function findUsedSubgraphIds(rootGraph: GraphOrSubgraph, subgraphRegistry: Map<UUID, GraphOrSubgraph>): Set<UUID>;
+/**
+ * Type guard to check if a slot is a SubgraphInput.
+ * @param slot The slot to check
+ * @returns true if the slot is a SubgraphInput
+ */
+export declare function isSubgraphInput(slot: unknown): slot is SubgraphInput;
+/**
+ * Type guard to check if a slot is a SubgraphOutput.
+ * @param slot The slot to check
+ * @returns true if the slot is a SubgraphOutput
+ */
+export declare function isSubgraphOutput(slot: unknown): slot is SubgraphOutput;
+/**
+ * Type guard to check if a slot is a regular node slot (INodeInputSlot or INodeOutputSlot).
+ * @param slot The slot to check
+ * @returns true if the slot is a regular node slot
+ */
+export declare function isNodeSlot(slot: unknown): slot is INodeInputSlot | INodeOutputSlot;
+export {};

package/dist/types/NodeLike.d.ts

@@ -0,0 +1,7 @@
+import { INodeInputSlot, INodeOutputSlot } from '../interfaces';
+import { NodeId } from '../LGraphNode';
+import { SubgraphIO } from './serialisation';
+export interface NodeLike {
+    id: NodeId;
+    canConnectTo(node: NodeLike, toSlot: INodeInputSlot | SubgraphIO, fromSlot: INodeOutputSlot | SubgraphIO): boolean;
+}

package/dist/types/events.d.ts

@@ -0,0 +1,64 @@
+import { LGraphGroup } from '../LGraphGroup';
+import { LGraphNode } from '../LGraphNode';
+import { LinkReleaseContextExtended } from '../litegraph';
+/** For Canvas*Event - adds graph space co-ordinates (property names are shipped) */
+export interface ICanvasPosition {
+    /** X co-ordinate of the event, in graph space (NOT canvas space) */
+    canvasX: number;
+    /** Y co-ordinate of the event, in graph space (NOT canvas space) */
+    canvasY: number;
+}
+/** For Canvas*Event */
+export interface IDeltaPosition {
+    deltaX: number;
+    deltaY: number;
+}
+/**
+ * Workaround for Firefox returning 0 on offsetX/Y props
+ * See https://github.com/Comfy-Org/litegraph.js/issues/403 for details
+ */
+export interface IOffsetWorkaround {
+    /** See {@link MouseEvent.offsetX}.  This workaround is required (2024-12-31) to support Firefox, which always returns 0 */
+    safeOffsetX: number;
+    /** See {@link MouseEvent.offsetY}.  This workaround is required (2024-12-31) to support Firefox, which always returns 0 */
+    safeOffsetY: number;
+}
+/** All properties added when converting a pointer event to a CanvasPointerEvent (via {@link LGraphCanvas.adjustMouseEvent}). */
+export type CanvasPointerExtensions = ICanvasPosition & IDeltaPosition & IOffsetWorkaround;
+interface LegacyMouseEvent {
+    /** @deprecated Part of DragAndScale mouse API - incomplete / not maintained */
+    dragging?: boolean;
+    click_time?: number;
+}
+/** PointerEvent with canvasX/Y and deltaX/Y properties */
+export interface CanvasPointerEvent extends PointerEvent, CanvasMouseEvent {
+}
+/** MouseEvent with canvasX/Y and deltaX/Y properties */
+export interface CanvasMouseEvent extends MouseEvent, Readonly<CanvasPointerExtensions>, LegacyMouseEvent {
+}
+/** DragEvent with canvasX/Y and deltaX/Y properties */
+export interface CanvasDragEvent extends DragEvent, CanvasPointerExtensions {
+}
+export type CanvasEventDetail = GenericEventDetail | GroupDoubleClickEventDetail | NodeDoubleClickEventDetail | EmptyDoubleClickEventDetail | EmptyReleaseEventDetail;
+export interface GenericEventDetail {
+    subType: "before-change" | "after-change";
+}
+export interface OriginalEvent {
+    originalEvent: CanvasPointerEvent;
+}
+export interface EmptyReleaseEventDetail extends OriginalEvent {
+    subType: "empty-release";
+    linkReleaseContext: LinkReleaseContextExtended;
+}
+export interface EmptyDoubleClickEventDetail extends OriginalEvent {
+    subType: "empty-double-click";
+}
+export interface GroupDoubleClickEventDetail extends OriginalEvent {
+    subType: "group-double-click";
+    group: LGraphGroup;
+}
+export interface NodeDoubleClickEventDetail extends OriginalEvent {
+    subType: "node-double-click";
+    node: LGraphNode;
+}
+export {};

package/dist/types/globalEnums.d.ts

@@ -0,0 +1,130 @@
+/** Node slot type - input or output */
+export declare enum NodeSlotType {
+    INPUT = 1,
+    OUTPUT = 2
+}
+/** Shape that an object will render as - used by nodes and slots */
+export declare enum RenderShape {
+    /** Rectangle with square corners */
+    BOX = 1,
+    /** Rounded rectangle */
+    ROUND = 2,
+    /** Circle is circle */
+    CIRCLE = 3,
+    /** Two rounded corners: top left & bottom right */
+    CARD = 4,
+    /** Slot shape: Arrow */
+    ARROW = 5,
+    /** Slot shape: Grid */
+    GRID = 6,
+    /** Slot shape: Hollow circle  */
+    HollowCircle = 7
+}
+/** Bit flags used to indicate what the pointer is currently hovering over. */
+export declare enum CanvasItem {
+    /** No items / none */
+    Nothing = 0,
+    /** At least one node */
+    Node = 1,
+    /** At least one group */
+    Group = 2,
+    /** A reroute (not its path) */
+    Reroute = 4,
+    /** The path of a link */
+    Link = 8,
+    /** A reroute slot */
+    RerouteSlot = 32,
+    /** A subgraph input or output node */
+    SubgraphIoNode = 64,
+    /** A subgraph input or output slot */
+    SubgraphIoSlot = 128
+}
+/** The direction that a link point will flow towards - e.g. horizontal outputs are right by default */
+export declare enum LinkDirection {
+    NONE = 0,
+    UP = 1,
+    DOWN = 2,
+    LEFT = 3,
+    RIGHT = 4,
+    CENTER = 5
+}
+/** The path calculation that links follow */
+export declare enum LinkRenderType {
+    HIDDEN_LINK = -1,
+    /** Juts out from the input & output a little @see LinkDirection, then a straight line between them */
+    STRAIGHT_LINK = 0,
+    /** 90° angles, clean and box-like */
+    LINEAR_LINK = 1,
+    /** Smooth curved links - default */
+    SPLINE_LINK = 2
+}
+/** The marker in the middle of a link */
+export declare enum LinkMarkerShape {
+    /** Do not display markers */
+    None = 0,
+    /** Circles (default) */
+    Circle = 1,
+    /** Directional arrows */
+    Arrow = 2
+}
+export declare enum TitleMode {
+    NORMAL_TITLE = 0,
+    NO_TITLE = 1,
+    TRANSPARENT_TITLE = 2,
+    AUTOHIDE_TITLE = 3
+}
+export declare enum LGraphEventMode {
+    ALWAYS = 0,
+    ON_EVENT = 1,
+    NEVER = 2,
+    ON_TRIGGER = 3,
+    BYPASS = 4
+}
+export declare enum EaseFunction {
+    LINEAR = "linear",
+    EASE_IN_QUAD = "easeInQuad",
+    EASE_OUT_QUAD = "easeOutQuad",
+    EASE_IN_OUT_QUAD = "easeInOutQuad"
+}
+/** Bit flags used to indicate what the pointer is currently hovering over. */
+export declare enum Alignment {
+    /** No items / none */
+    None = 0,
+    /** Top */
+    Top = 1,
+    /** Bottom */
+    Bottom = 2,
+    /** Vertical middle */
+    Middle = 4,
+    /** Left */
+    Left = 8,
+    /** Right */
+    Right = 16,
+    /** Horizontal centre */
+    Centre = 32,
+    /** Top left */
+    TopLeft = 9,
+    /** Top side, horizontally centred */
+    TopCentre = 33,
+    /** Top right */
+    TopRight = 17,
+    /** Left side, vertically centred */
+    MidLeft = 12,
+    /** Middle centre */
+    MidCentre = 36,
+    /** Right side, vertically centred */
+    MidRight = 20,
+    /** Bottom left */
+    BottomLeft = 10,
+    /** Bottom side, horizontally centred */
+    BottomCentre = 34,
+    /** Bottom right */
+    BottomRight = 18
+}
+/**
+ * Checks if the bitwise {@link flag} is set in the {@link flagSet}.
+ * @param flagSet The unknown set of flags - will be checked for the presence of {@link flag}
+ * @param flag The flag to check for
+ * @returns `true` if the flag is set, `false` otherwise.
+ */
+export declare function hasFlag(flagSet: number, flag: number): boolean;