@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/avatar/util/getEffectSprite.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEffectSprite = getEffectSprite;
+const getFlippedMetaData_1 = require("./getFlippedMetaData");
+const AvatarEffectPart_1 = require("../structure/AvatarEffectPart");
+function getEffectSprite(member, direction, frame, offsetsData, hasDirection, handleFlipped) {
+    let id = (0, AvatarEffectPart_1.getSpriteId)(member, direction, frame);
+    let offsets = offsetsData.getOffsets(id);
+    let flip = false;
+    if (handleFlipped && offsets == null) {
+        const flippedMeta = (0, getFlippedMetaData_1.getBasicFlippedMetaData)(direction);
+        id = (0, AvatarEffectPart_1.getSpriteId)(member, flippedMeta.direction, frame);
+        offsets = offsetsData.getOffsets(id);
+        flip = flippedMeta.flip;
+    }
+    if (!hasDirection) {
+        id = (0, AvatarEffectPart_1.getSpriteId)(member, 0, frame);
+        if (offsets == null) {
+            offsets = offsetsData.getOffsets(id);
+        }
+    }
+    return {
+        id,
+        offsets,
+        flip,
+    };
+}

package/dist/objects/avatar/util/getFlippedMetaData.d.ts

@@ -0,0 +1,36 @@
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+export declare const DIRECTION_IS_FLIPPED: boolean[];
+export declare function getFlippedMetaData({ assetPartDefinition, direction, partType, flippedPartType, }: {
+    assetPartDefinition: string;
+    partType: AvatarFigurePartType;
+    flippedPartType?: AvatarFigurePartType;
+    direction: number;
+}): {
+    direction: number;
+    flip: boolean;
+    partType: AvatarFigurePartType;
+    swapped: boolean;
+} | {
+    swapped?: undefined;
+    direction: number;
+    flip: boolean;
+    partType: AvatarFigurePartType.Body | AvatarFigurePartType.Shoes | AvatarFigurePartType.Legs | AvatarFigurePartType.Chest | AvatarFigurePartType.WaistAccessory | AvatarFigurePartType.ChestAccessory | AvatarFigurePartType.Head | AvatarFigurePartType.Hair | AvatarFigurePartType.FaceAccessory | AvatarFigurePartType.EyeAccessory | AvatarFigurePartType.HeadAccessory | AvatarFigurePartType.HeadAccessoryExtra | AvatarFigurePartType.CoatChest | AvatarFigurePartType.LeftHand | AvatarFigurePartType.LeftSleeve | AvatarFigurePartType.RightHand | AvatarFigurePartType.RightSleeve | AvatarFigurePartType.Face | AvatarFigurePartType.Eyes | AvatarFigurePartType.HairBig | AvatarFigurePartType.LeftCoatSleeve | AvatarFigurePartType.RightCoatSleeve;
+};
+export declare function getBasicFlippedMetaData(direction: number): {
+    direction: number;
+    flip: boolean;
+};
+export declare function getPartFlippedMetaData(direction: number, { partType, flippedPartType, }: {
+    partType?: AvatarFigurePartType;
+    flippedPartType?: AvatarFigurePartType;
+}): {
+    direction: number;
+    flip: boolean;
+    partType: AvatarFigurePartType | undefined;
+    swapped: boolean;
+} | {
+    swapped?: undefined;
+    direction: number;
+    flip: boolean;
+    partType: AvatarFigurePartType | undefined;
+};

package/dist/objects/avatar/util/getFlippedMetaData.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIRECTION_IS_FLIPPED = void 0;
+exports.getFlippedMetaData = getFlippedMetaData;
+exports.getBasicFlippedMetaData = getBasicFlippedMetaData;
+exports.getPartFlippedMetaData = getPartFlippedMetaData;
+const AvatarFigurePartType_1 = require("../enum/AvatarFigurePartType");
+exports.DIRECTION_IS_FLIPPED = [
+    false,
+    false,
+    false,
+    false,
+    true,
+    true,
+    true,
+    false,
+];
+function getFlippedMetaData({ assetPartDefinition, direction, partType, flippedPartType, }) {
+    const directionFlipped = exports.DIRECTION_IS_FLIPPED[direction];
+    if (!directionFlipped) {
+        return { direction, flip: false, partType, swapped: false };
+    }
+    if (assetPartDefinition === "wav" &&
+        (partType == AvatarFigurePartType_1.AvatarFigurePartType.LeftHand ||
+            partType == AvatarFigurePartType_1.AvatarFigurePartType.LeftSleeve ||
+            partType == AvatarFigurePartType_1.AvatarFigurePartType.LeftCoatSleeve)) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "drk" &&
+        (partType == AvatarFigurePartType_1.AvatarFigurePartType.RightHand ||
+            partType == AvatarFigurePartType_1.AvatarFigurePartType.RightSleeve ||
+            partType == AvatarFigurePartType_1.AvatarFigurePartType.RightCoatSleeve)) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "blw" &&
+        partType == AvatarFigurePartType_1.AvatarFigurePartType.RightHand) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "sig" &&
+        partType == AvatarFigurePartType_1.AvatarFigurePartType.LeftHand) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "respect" &&
+        partType == AvatarFigurePartType_1.AvatarFigurePartType.LeftHand) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (partType == AvatarFigurePartType_1.AvatarFigurePartType.RightHandItem) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (partType == AvatarFigurePartType_1.AvatarFigurePartType.LeftHandItem) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (partType == AvatarFigurePartType_1.AvatarFigurePartType.ChestPrint) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    const overrideDirection = getBasicFlippedMetaData(direction);
+    if (flippedPartType != partType) {
+        return {
+            direction: overrideDirection.direction,
+            flip: false,
+            partType: flippedPartType !== null && flippedPartType !== void 0 ? flippedPartType : partType,
+            swapped: true,
+        };
+    }
+    return { direction: overrideDirection.direction, flip: false, partType };
+}
+function getBasicFlippedMetaData(direction) {
+    let overrideDirection = direction;
+    let flipped = false;
+    if (direction === 4) {
+        overrideDirection = 2;
+        flipped = true;
+    }
+    if (direction === 5) {
+        overrideDirection = 1;
+        flipped = true;
+    }
+    if (direction === 6) {
+        overrideDirection = 0;
+        flipped = true;
+    }
+    return { direction: overrideDirection, flip: flipped };
+}
+function getPartFlippedMetaData(direction, { partType, flippedPartType, }) {
+    const overrideDirection = getBasicFlippedMetaData(direction);
+    if (flippedPartType != partType) {
+        return {
+            direction: overrideDirection.direction,
+            flip: false,
+            partType: flippedPartType !== null && flippedPartType !== void 0 ? flippedPartType : partType,
+            swapped: true,
+        };
+    }
+    return { direction: overrideDirection.direction, flip: false, partType };
+}

package/dist/objects/avatar/util/getLibrariesForLook.d.ts

@@ -0,0 +1,7 @@
+import { IFigureData } from "../data/interfaces/IFigureData";
+import { IFigureMapData } from "../data/interfaces/IFigureMapData";
+import { ParsedLook } from "./parseLookString";
+export declare function getLibrariesForLook(look: ParsedLook, { figureMap, figureData, }: {
+    figureMap: IFigureMapData;
+    figureData: IFigureData;
+}): Set<string>;

package/dist/objects/avatar/util/getLibrariesForLook.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibrariesForLook = getLibrariesForLook;
+function getLibrariesForLook(look, { figureMap, figureData, }) {
+    var _a;
+    const libraries = new Set();
+    const figureParts = Array.from(look).flatMap(([setType, { setId }]) => {
+        var _a;
+        var _b;
+        return ((_b = (_a = figureData
+            .getParts(setType, setId.toString())) === null || _a === void 0 ? void 0 : _a.map((part) => ({ ...part, setId, setType }))) !== null && _b !== void 0 ? _b : []);
+    });
+    for (const part of figureParts) {
+        let libraryId = figureMap.getLibraryOfPart(part.id, part.type);
+        if (libraryId != null) {
+            const checkParts = (_a = figureData.getParts(part.setType, part.setId.toString())) !== null && _a !== void 0 ? _a : [];
+            for (const checkPart of checkParts) {
+                libraryId = figureMap.getLibraryOfPart(checkPart.id, checkPart.type);
+                if (libraryId != null)
+                    break;
+            }
+        }
+        if (libraryId != null) {
+            libraries.add(libraryId);
+        }
+    }
+    // Add base libraries
+    libraries.add("hh_human_face");
+    libraries.add("hh_human_item");
+    libraries.add("hh_human_body");
+    return libraries;
+}

package/dist/objects/avatar/util/index.d.ts

@@ -0,0 +1 @@
+export * from "./createLookServer";

package/dist/objects/avatar/util/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createLookServer"), exports);

package/dist/objects/avatar/util/parseLookString.d.ts

@@ -0,0 +1,5 @@
+export type ParsedLook = Map<string, {
+    setId: number;
+    colorId: number;
+}>;
+export declare function parseLookString(look: string): ParsedLook;

package/dist/objects/avatar/util/parseLookString.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLookString = parseLookString;
+function parseLookString(look) {
+    return new Map(look.split(".").map((str) => {
+        const partData = str.split("-");
+        return [
+            partData[0],
+            {
+                setId: Number(partData[1]),
+                colorId: Number(partData[2]),
+            },
+        ];
+    }));
+}

package/dist/objects/events/EventEmitter.d.ts

@@ -0,0 +1,11 @@
+export declare class EventEmitter<TMap extends BaseTypeMap<unknown>> {
+    private _map;
+    addEventListener<K extends keyof TMap>(name: K, callback: EventCallback<K, TMap>): void;
+    removeEventListener<K extends keyof TMap>(name: K, callback: EventCallback<K, TMap>): void;
+    trigger<K extends keyof TMap>(name: K, value: TMap[K]): void;
+}
+type EventCallback<K extends keyof TMap, TMap extends BaseTypeMap<unknown>> = (event: TMap[K]) => void;
+type BaseTypeMap<T> = {
+    [k in keyof T]: unknown;
+};
+export {};

package/dist/objects/events/EventEmitter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventEmitter = void 0;
+class EventEmitter {
+    constructor() {
+        this._map = new Map();
+    }
+    addEventListener(name, callback) {
+        var _a;
+        const key = name.toString();
+        const currentEventCallbackSet = (_a = this._map.get(key)) !== null && _a !== void 0 ? _a : new Set();
+        currentEventCallbackSet.add(callback);
+        this._map.set(key, currentEventCallbackSet);
+    }
+    removeEventListener(name, callback) {
+        const key = name.toString();
+        const currentEventCallbackSet = this._map.get(key);
+        if (currentEventCallbackSet != null) {
+            currentEventCallbackSet.delete(callback);
+        }
+    }
+    trigger(name, value) {
+        const key = name.toString();
+        const currentEventCallbackSet = this._map.get(key);
+        currentEventCallbackSet === null || currentEventCallbackSet === void 0 ? void 0 : currentEventCallbackSet.forEach((callback) => callback(value));
+    }
+}
+exports.EventEmitter = EventEmitter;
+if (typeof window !== 'undefined') {
+    window.addEventListener;
+}

package/dist/objects/events/EventManager.d.ts

@@ -0,0 +1,27 @@
+import { IEventManagerNode } from "./interfaces/IEventManagerNode";
+import { IEventTarget } from "./interfaces/IEventTarget";
+import { IEventManager } from "./interfaces/IEventManager";
+import { Container, FederatedPointerEvent, Matrix } from "pixi.js";
+export declare class EventManager {
+    coordinateRoot: Container | undefined;
+    private _nodes;
+    private _bush;
+    private _currentOverElements;
+    private _pointerDownElements;
+    private _pointerDownPosition;
+    private _onBackgroundClick;
+    private _targets;
+    private _currentTarget;
+    set onBackgroundClick(value: ((event: FederatedPointerEvent) => void) | undefined);
+    reset(): void;
+    click(event: FederatedPointerEvent, x: number, y: number): void;
+    pointerDown(event: FederatedPointerEvent, x: number, y: number): void;
+    pointerUp(event: FederatedPointerEvent, x: number, y: number): void;
+    private _exceededDragThreshold;
+    move(event: FederatedPointerEvent, x: number, y: number): void;
+    register(target: IEventTarget): IEventManagerNode;
+    remove(target: IEventTarget): void;
+    getCoordinateRootMatrix(): Matrix | undefined;
+    private _performHitTest;
+}
+export declare const NOOP_EVENT_MANAGER: IEventManager;

package/dist/objects/events/EventManager.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP_EVENT_MANAGER = exports.EventManager = void 0;
+const EventManagerNode_1 = require("./EventManagerNode");
+const rbush_1 = __importDefault(require("rbush"));
+const IEventGroup_1 = require("./interfaces/IEventGroup");
+const DRAG_THRESHOLD = 10;
+class EventManager {
+    constructor() {
+        this._nodes = new Map();
+        this._bush = new rbush_1.default();
+        this._currentOverElements = new Set();
+        this._pointerDownElements = new Set();
+        this._pointerDownPosition = undefined;
+        this._onBackgroundClick = undefined;
+        this._targets = new Set();
+    }
+    set onBackgroundClick(value) {
+        this._onBackgroundClick = value;
+    }
+    reset() {
+        this._targets.forEach(target => this.remove(target));
+        this._targets.clear();
+        this._currentTarget = undefined;
+    }
+    click(event, x, y) {
+        if (this._exceededDragThreshold(x, y))
+            return;
+        const elements = this._performHitTest(x, y);
+        let nodes = elements.activeNodes;
+        if (nodes.length === 0 && this._pointerDownElements.size > 0) {
+            nodes = Array.from(this._pointerDownElements);
+        }
+        new Propagation(event, nodes, (target, event) => target.triggerClick(event));
+    }
+    pointerDown(event, x, y) {
+        const elements = this._performHitTest(x, y);
+        this._pointerDownElements = new Set(elements.activeNodes);
+        this._pointerDownPosition = { x, y };
+        new Propagation(event, elements.activeNodes, (target, event) => target.triggerPointerDown(event));
+    }
+    pointerUp(event, x, y) {
+        const dragged = this._exceededDragThreshold(x, y);
+        const elements = this._performHitTest(x, y);
+        const elementsSet = new Set(elements.activeNodes);
+        const downGroups = new Set();
+        this._pointerDownElements.forEach((node) => {
+            downGroups.add(node.target.getGroup());
+        });
+        let clickedNodes = new Set();
+        elements.activeNodes.forEach((node) => {
+            if (downGroups.has(node.target.getGroup())) {
+                clickedNodes.add(node);
+            }
+        });
+        if (clickedNodes.size === 0 && this._pointerDownElements.size === 0 && this._pointerDownPosition) {
+            const downElements = this._performHitTest(this._pointerDownPosition.x, this._pointerDownPosition.y);
+            downElements.activeNodes.forEach((node) => clickedNodes.add(node));
+        }
+        if (dragged) {
+            clickedNodes = new Set();
+        }
+        if (!dragged &&
+            elements.activeNodes.length === 0 &&
+            clickedNodes.size === 0 &&
+            this._onBackgroundClick) {
+            this._onBackgroundClick(event);
+        }
+        new Propagation(event, elements.activeNodes, (target, event) => target.triggerPointerUp(event));
+        new Propagation(event, Array.from(clickedNodes), (target, event) => {
+            target.triggerClick(event);
+        });
+        this._pointerDownPosition = undefined;
+    }
+    _exceededDragThreshold(x, y) {
+        const start = this._pointerDownPosition;
+        if (start == null)
+            return false;
+        const distance = Math.sqrt((x - start.x) ** 2 + (y - start.y) ** 2);
+        return distance >= DRAG_THRESHOLD;
+    }
+    move(event, x, y) {
+        const elements = this._performHitTest(x, y);
+        const current = new Set(elements.activeNodes.filter((node, index) => 
+        // Only interested in the top most element
+        index === 0 ||
+            // or the tile cursor
+            node.target.getGroup().getEventGroupIdentifier() === IEventGroup_1.TILE_CURSOR));
+        const previous = this._currentOverElements;
+        const added = new Set();
+        current.forEach((node) => {
+            if (!previous.has(node)) {
+                added.add(node);
+            }
+        });
+        const removed = new Set();
+        previous.forEach((node) => {
+            if (!current.has(node)) {
+                removed.add(node);
+            }
+        });
+        const addedGroups = new Set();
+        added.forEach((node) => {
+            addedGroups.add(node.target.getGroup());
+        });
+        const removedButGroupPresent = new Set();
+        const actualRemoved = new Set();
+        removed.forEach((node) => {
+            if (addedGroups.has(node.target.getGroup())) {
+                removedButGroupPresent.add(node);
+            }
+            actualRemoved.add(node);
+        });
+        this._currentOverElements = current;
+        new Propagation(event, Array.from(removedButGroupPresent), (target, event) => {
+            target.triggerPointerTargetChanged(event);
+        });
+        new Propagation(event, Array.from(actualRemoved), (target, event) => target.triggerPointerOut(event));
+        new Propagation(event, Array.from(added), (target, event) => target.triggerPointerOver(event));
+    }
+    register(target) {
+        if (this._nodes.has(target))
+            throw new Error("Target already registered");
+        const node = new EventManagerNode_1.EventManagerNode(target, this._bush);
+        this._nodes.set(target, node);
+        this._targets.add(target);
+        return node;
+    }
+    remove(target) {
+        const current = this._nodes.get(target);
+        if (current == null)
+            throw new Error("Target isn't in the event manager");
+        current.destroy();
+        this._targets.delete(target);
+    }
+    getCoordinateRootMatrix() {
+        var _a;
+        return (_a = this.coordinateRoot) === null || _a === void 0 ? void 0 : _a.worldTransform;
+    }
+    _performHitTest(x, y) {
+        let indexX = x;
+        let indexY = y;
+        const m = this.getCoordinateRootMatrix();
+        if (m != null) {
+            indexX = (x - m.tx) / m.a;
+            indexY = (y - m.ty) / m.d;
+        }
+        const qualifyingElements = this._bush.search({
+            minX: indexX,
+            minY: indexY,
+            maxX: indexX,
+            maxY: indexY,
+        });
+        const sortedElements = qualifyingElements
+            .sort((a, b) => b.target.getEventZOrder() - a.target.getEventZOrder())
+            .filter((node) => node.target.hits(x, y));
+        const groups = new Map();
+        const groupElements = [];
+        sortedElements.forEach((node) => {
+            const group = node.target.getGroup();
+            if (group != null && groups.has(group))
+                return;
+            groupElements.push(node);
+            if (group != null) {
+                groups.set(group, node);
+            }
+        });
+        return {
+            activeNodes: groupElements,
+            activeGroups: groups,
+        };
+    }
+}
+exports.EventManager = EventManager;
+class Propagation {
+    constructor(event, path, _trigger) {
+        this.event = event;
+        this.path = path;
+        this._trigger = _trigger;
+        this._skip = new Set();
+        this._allow = new Set();
+        this._stopped = false;
+        this._propagate();
+    }
+    _propagate() {
+        const event = this._createEvent();
+        for (let i = 0; i < this.path.length; i++) {
+            if (this._stopped)
+                return;
+            const node = this.path[i];
+            if (this._skip.has(node.target.getGroup().getEventGroupIdentifier()) &&
+                !this._allow.has(node.target.getGroup().getEventGroupIdentifier())) {
+                continue;
+            }
+            if (this._allow.size > 0 &&
+                !this._allow.has(node.target.getGroup().getEventGroupIdentifier())) {
+                continue;
+            }
+            this._trigger(this.path[i].target, event);
+        }
+    }
+    _createEvent() {
+        return {
+            interactionEvent: this.event,
+            mouseEvent: this.event.nativeEvent,
+            stopPropagation: () => {
+                this._stopped = true;
+            },
+            skip: (...identifiers) => {
+                const add = (identifier) => {
+                    if (Array.isArray(identifier)) {
+                        identifier.forEach((value) => add(value));
+                    }
+                    else {
+                        this._skip.add(identifier);
+                    }
+                };
+                add(identifiers);
+            },
+            skipExcept: (...identifiers) => {
+                const add = (identifier) => {
+                    if (Array.isArray(identifier)) {
+                        identifier.forEach((value) => add(value));
+                    }
+                    else {
+                        this._allow.add(identifier);
+                    }
+                };
+                add(identifiers);
+            },
+        };
+    }
+}
+exports.NOOP_EVENT_MANAGER = {
+    register: () => {
+        return {
+            destroy: () => {
+                // Do nothing
+            },
+        };
+    },
+    remove: () => {
+        // Do nothing
+    },
+};

package/dist/objects/events/EventManagerContainer.d.ts

@@ -0,0 +1,11 @@
+import * as PIXI from "pixi.js";
+import { EventManager } from "./EventManager";
+export declare class EventManagerContainer {
+    private _application;
+    private _eventManager;
+    private _onPointerMove;
+    private _onPointerUp;
+    private _onPointerDown;
+    constructor(_application: PIXI.Application, _eventManager: EventManager);
+    destroy(): void;
+}

package/dist/objects/events/EventManagerContainer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventManagerContainer = void 0;
+class EventManagerContainer {
+    constructor(_application, _eventManager) {
+        this._application = _application;
+        this._eventManager = _eventManager;
+        const stage = this._application.stage;
+        stage.eventMode = "static";
+        stage.hitArea = this._application.screen;
+        this._onPointerMove = (event) => {
+            const position = stage.toLocal(event.global);
+            this._eventManager.move(event, position.x, position.y);
+        };
+        this._onPointerUp = (event) => {
+            const position = stage.toLocal(event.global);
+            this._eventManager.pointerUp(event, position.x, position.y);
+        };
+        this._onPointerDown = (event) => {
+            const position = stage.toLocal(event.global);
+            this._eventManager.pointerDown(event, position.x, position.y);
+        };
+        stage.on("pointermove", this._onPointerMove);
+        stage.on("pointerup", this._onPointerUp);
+        stage.on("pointerdown", this._onPointerDown);
+    }
+    destroy() {
+        const stage = this._application.stage;
+        if (stage != null) {
+            stage.off("pointermove", this._onPointerMove);
+            stage.off("pointerup", this._onPointerUp);
+            stage.off("pointerdown", this._onPointerDown);
+        }
+    }
+}
+exports.EventManagerContainer = EventManagerContainer;

package/dist/objects/events/EventManagerNode.d.ts

@@ -0,0 +1,16 @@
+import RBush from "rbush";
+import { IEventManagerNode } from "./interfaces/IEventManagerNode";
+import { IEventTarget } from "./interfaces/IEventTarget";
+export declare class EventManagerNode implements IEventManagerNode {
+    readonly target: IEventTarget;
+    private _bush;
+    private _rectangle;
+    private _subscription;
+    get minX(): number;
+    get maxX(): number;
+    get minY(): number;
+    get maxY(): number;
+    constructor(target: IEventTarget, _bush: RBush<EventManagerNode>);
+    destroy(): void;
+    private _updateRectangle;
+}