@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/avatar/data/AvatarEffectData.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarEffectData = void 0;
+const getNumberFromAttribute_1 = require("../../../util/getNumberFromAttribute");
+class AvatarEffectData {
+    constructor(string) {
+        this._frameBodyParts = new Map();
+        this._frameFxParts = new Map();
+        this._sprites = new Map();
+        this._additions = new Map();
+        this._spriteDirections = new Map();
+        this._frameBodyPartsById = new Map();
+        this._frameBodyPartByBase = new Map();
+        this._frameFxPartsById = new Map();
+        const document = new DOMParser().parseFromString(string, "text/xml");
+        const frameElements = document.querySelectorAll("animation > frame");
+        frameElements.forEach((frame, index) => {
+            frame.querySelectorAll("bodypart").forEach((bodypart) => {
+                var _a;
+                const bodyPart = this._getFrameBodyPartFromElement(bodypart);
+                const current = (_a = this._frameBodyParts.get(index)) !== null && _a !== void 0 ? _a : [];
+                this._frameBodyParts.set(index, [...current, bodyPart]);
+                this._frameBodyPartsById.set(`${bodypart.id}_${index}`, bodyPart);
+                if (bodyPart.base != null) {
+                    this._frameBodyPartByBase.set(`${bodyPart.base}_${index}`, bodyPart);
+                }
+            });
+            frame.querySelectorAll("fx").forEach((element) => {
+                var _a;
+                const fxPart = this._getFXPartFromElement(element);
+                const current = (_a = this._frameFxParts.get(index)) !== null && _a !== void 0 ? _a : [];
+                if (fxPart != null) {
+                    this._frameFxParts.set(index, [...current, fxPart]);
+                    this._frameFxPartsById.set(`${fxPart.id}_${index}`, fxPart);
+                }
+            });
+        });
+        document.querySelectorAll("sprite").forEach((element) => {
+            const sprite = this._getEffectSpriteFromElement(element);
+            this._sprites.set(sprite.id, sprite);
+            element.querySelectorAll("direction").forEach((element) => {
+                const direction = this._getDirectionSpriteFromElement(element);
+                this._spriteDirections.set(`${sprite.id}_${direction.id}`, direction);
+            });
+        });
+        document.querySelectorAll("add").forEach((element) => {
+            const addition = this._getFXAddition(element);
+            this._additions.set(addition.id, addition);
+        });
+        const directionElement = document.querySelector("animation > direction");
+        if (directionElement != null) {
+            this._direction = this._getDirectionFromElement(directionElement);
+        }
+        this._frameCount = frameElements.length;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarEffectData(text);
+    }
+    getFrameBodyPartByBase(bodyPartId, frame) {
+        return this._frameBodyPartByBase.get(`${bodyPartId}_${frame}`);
+    }
+    getFrameEffectPart(id, frame) {
+        return this._frameFxPartsById.get(`${id}_${frame}`);
+    }
+    getFrameBodyPart(bodyPartId, frame) {
+        return this._frameBodyPartsById.get(`${bodyPartId}_${frame}`);
+    }
+    getAddtions() {
+        return Array.from(this._additions.values());
+    }
+    getFrameEffectParts(frame) {
+        var _a;
+        return (_a = this._frameFxParts.get(frame)) !== null && _a !== void 0 ? _a : [];
+    }
+    getDirection() {
+        return this._direction;
+    }
+    getFrameBodyParts(frame) {
+        var _a;
+        return (_a = this._frameBodyParts.get(frame)) !== null && _a !== void 0 ? _a : [];
+    }
+    getFrameCount() {
+        return this._frameCount;
+    }
+    getSprites() {
+        return Array.from(this._sprites.values());
+    }
+    getSpriteDirection(id, direction) {
+        return this._spriteDirections.get(`${id}_${direction}`);
+    }
+    _getFXAddition(element) {
+        var _a, _b, _c;
+        const id = (_a = element.getAttribute("id")) !== null && _a !== void 0 ? _a : undefined;
+        const align = (_b = element.getAttribute("align")) !== null && _b !== void 0 ? _b : undefined;
+        const base = (_c = element.getAttribute("base")) !== null && _c !== void 0 ? _c : undefined;
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            align,
+            base,
+        };
+    }
+    _getFXPartFromElement(element) {
+        // action="Default" frame="0" dx="2" dy="0" dd="6"
+        const action = element.getAttribute("action");
+        const frame = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("frame"));
+        const dx = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dx"));
+        const dy = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dy"));
+        const dd = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dd"));
+        const id = element.getAttribute("id");
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            action: action !== null && action !== void 0 ? action : undefined,
+            frame,
+            dx,
+            dy,
+            dd,
+        };
+    }
+    _getDirectionFromElement(element) {
+        const offset = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("offset"));
+        if (offset == null)
+            return;
+        return {
+            offset,
+        };
+    }
+    _getDirectionSpriteFromElement(element) {
+        const id = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("id"));
+        const dz = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dz"));
+        const dx = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dx"));
+        const dy = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dy"));
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            dz,
+            dx,
+            dy,
+        };
+    }
+    _getEffectSpriteFromElement(element) {
+        var _a;
+        const id = element.getAttribute("id");
+        const ink = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("ink"));
+        const member = (_a = element.getAttribute("member")) !== null && _a !== void 0 ? _a : undefined;
+        const staticY = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("staticY"));
+        const directions = element.getAttribute("directions") === "1";
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            ink,
+            member,
+            staticY,
+            directions,
+        };
+    }
+    _getFrameBodyPartFromElement(element) {
+        var _a, _b;
+        const action = (_a = element.getAttribute("action")) !== null && _a !== void 0 ? _a : undefined;
+        const id = element.getAttribute("id");
+        const frame = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("frame"));
+        const dx = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dx"));
+        const dy = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dy"));
+        const dd = (0, getNumberFromAttribute_1.getNumberFromAttribute)(element.getAttribute("dd"));
+        const base = (_b = element.getAttribute("base")) !== null && _b !== void 0 ? _b : undefined;
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            action,
+            frame,
+            id,
+            dx,
+            dy,
+            dd,
+            base,
+        };
+    }
+}
+exports.AvatarEffectData = AvatarEffectData;

package/dist/objects/avatar/data/AvatarEffectMap.d.ts

@@ -0,0 +1,9 @@
+import { AvatarEffect, IAvatarEffectMap } from "./interfaces/IAvatarEffectMap";
+export declare class AvatarEffectMap implements IAvatarEffectMap {
+    private _effects;
+    private _effectsArray;
+    constructor(string: string);
+    getEffects(): AvatarEffect[];
+    getEffectInfo(id: string): AvatarEffect | undefined;
+    private _getEffectFromElement;
+}

package/dist/objects/avatar/data/AvatarEffectMap.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarEffectMap = void 0;
+class AvatarEffectMap {
+    constructor(string) {
+        this._effects = new Map();
+        this._effectsArray = [];
+        const document = new DOMParser().parseFromString(string, "text/xml");
+        document.querySelectorAll("effect").forEach((element) => {
+            const effect = this._getEffectFromElement(element);
+            this._effects.set(effect.id, effect);
+            this._effectsArray.push(effect);
+        });
+    }
+    getEffects() {
+        return this._effectsArray;
+    }
+    getEffectInfo(id) {
+        return this._effects.get(id);
+    }
+    _getEffectFromElement(element) {
+        const id = element.getAttribute("id");
+        const lib = element.getAttribute("lib");
+        const type = element.getAttribute("type");
+        if (lib == null)
+            throw new Error("Invalid lib for effect");
+        if (type == null)
+            throw new Error("Invalid type for effect");
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            lib,
+            type,
+        };
+    }
+}
+exports.AvatarEffectMap = AvatarEffectMap;

package/dist/objects/avatar/data/AvatarGeometryData.d.ts

@@ -0,0 +1,17 @@
+import { AvatarGeometry, Bodypart, BodypartItem, IAvatarGeometryData } from "./interfaces/IAvatarGeometryData";
+export declare class AvatarGeometryData implements IAvatarGeometryData {
+    private _bodypartMap;
+    private _avatarSetMap;
+    private _geometries;
+    private _bodyPartItemMap;
+    constructor(string: string);
+    static fromUrl(url: string): Promise<AvatarGeometryData>;
+    static default(): AvatarGeometryData;
+    getBodyPartItem(geometry: string, bodyPartId: string, itemId: string): BodypartItem | undefined;
+    getBodyPart(geometry: string, bodyPartId: string): Bodypart | undefined;
+    getBodyParts(avaterSet: string): string[];
+    getGeometry(geometry: string): AvatarGeometry | undefined;
+    private _getGeometryFromElement;
+    private _getBodyPartFromElement;
+    private _getBodyPartItemFromElement;
+}

package/dist/objects/avatar/data/AvatarGeometryData.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarGeometryData = void 0;
+const getNumberFromAttribute_1 = require("../../../util/getNumberFromAttribute");
+const geometry_xml_1 = require("./static/geometry.xml");
+class AvatarGeometryData {
+    constructor(string) {
+        this._bodypartMap = new Map();
+        this._avatarSetMap = new Map();
+        this._geometries = new Map();
+        this._bodyPartItemMap = new Map();
+        const document = new DOMParser().parseFromString(string, "text/xml");
+        document
+            .querySelectorAll(`canvas[scale="h"] geometry`)
+            .forEach((element) => {
+            const geometry = this._getGeometryFromElement(element);
+            this._geometries.set(geometry.id, geometry);
+        });
+        document.querySelectorAll(`avatarset`).forEach((element) => {
+            const avatarSetId = element.getAttribute("id");
+            if (avatarSetId == null)
+                return;
+            const bodyParts = element.querySelectorAll(`bodypart`);
+            bodyParts.forEach((bodyPart) => {
+                var _a;
+                const id = bodyPart.getAttribute("id");
+                if (id != null) {
+                    const current = (_a = this._avatarSetMap.get(avatarSetId)) !== null && _a !== void 0 ? _a : [];
+                    this._avatarSetMap.set(avatarSetId, [...current, id]);
+                }
+            });
+        });
+        document.querySelectorAll(`type`).forEach((element) => {
+            const typeId = element.getAttribute("id");
+            if (typeId == null)
+                return;
+            element.querySelectorAll(`bodypart`).forEach((bodypart) => {
+                const bodyPart = this._getBodyPartFromElement(bodypart);
+                if (bodyPart == null)
+                    return;
+                const bodyPartItems = [];
+                bodypart.querySelectorAll(`item`).forEach((item) => {
+                    const bodyPartItem = this._getBodyPartItemFromElement(item);
+                    if (bodyPartItem != null) {
+                        bodyPartItems.push(bodyPartItem);
+                        this._bodyPartItemMap.set(`${typeId}_${bodyPart.id}_${bodyPartItem.id}`, bodyPartItem);
+                    }
+                });
+                this._bodypartMap.set(`${typeId}_${bodyPart.id}`, {
+                    ...bodyPart,
+                    items: bodyPartItems,
+                });
+            });
+        });
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarGeometryData(text);
+    }
+    static default() {
+        return new AvatarGeometryData(atob(geometry_xml_1.geometryXml));
+    }
+    getBodyPartItem(geometry, bodyPartId, itemId) {
+        return this._bodyPartItemMap.get(`${geometry}_${bodyPartId}_${itemId}`);
+    }
+    getBodyPart(geometry, bodyPartId) {
+        return this._bodypartMap.get(`${geometry}_${bodyPartId}`);
+    }
+    getBodyParts(avaterSet) {
+        var _a;
+        return (_a = this._avatarSetMap.get(avaterSet)) !== null && _a !== void 0 ? _a : [];
+    }
+    getGeometry(geometry) {
+        return this._geometries.get(geometry);
+    }
+    _getGeometryFromElement(element) {
+        const id = element.getAttribute("id");
+        const width = Number(element.getAttribute("width"));
+        const height = Number(element.getAttribute("height"));
+        const dx = Number(element.getAttribute("dx"));
+        const dy = Number(element.getAttribute("dy"));
+        if (id == null)
+            throw new Error("Invalid id");
+        return {
+            id,
+            width,
+            height,
+            dx,
+            dy,
+        };
+    }
+    _getBodyPartFromElement(item) {
+        const id = item.getAttribute("id");
+        const z = Number(item.getAttribute("z"));
+        if (id == null)
+            return;
+        if (isNaN(z))
+            return;
+        return {
+            id,
+            z,
+        };
+    }
+    _getBodyPartItemFromElement(item) {
+        const id = item.getAttribute("id");
+        const z = (0, getNumberFromAttribute_1.getNumberFromAttribute)(item.getAttribute("z"));
+        const radius = (0, getNumberFromAttribute_1.getNumberFromAttribute)(item.getAttribute("radius"));
+        if (id == null)
+            return;
+        if (z == null)
+            return;
+        if (radius == null)
+            return;
+        return {
+            id,
+            z,
+            radius,
+        };
+    }
+}
+exports.AvatarGeometryData = AvatarGeometryData;

package/dist/objects/avatar/data/AvatarManifestData.d.ts

@@ -0,0 +1,12 @@
+import { AvatarData } from "./AvatarData";
+import { IAvatarManifestData, ManifestAlias, ManifestAsset } from "./interfaces/IAvatarManifestData";
+export declare class AvatarManifestData extends AvatarData implements IAvatarManifestData {
+    private _assets;
+    private _assetbyName;
+    private _aliases;
+    constructor(xml: string);
+    getAliases(): ManifestAlias[];
+    getAssets(): ManifestAsset[];
+    getAssetByName(name: string): ManifestAsset | undefined;
+    private _cacheData;
+}

package/dist/objects/avatar/data/AvatarManifestData.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarManifestData = void 0;
+const AvatarData_1 = require("./AvatarData");
+class AvatarManifestData extends AvatarData_1.AvatarData {
+    constructor(xml) {
+        super(xml);
+        this._assets = [];
+        this._assetbyName = new Map();
+        this._aliases = [];
+        this._cacheData();
+    }
+    getAliases() {
+        return this._aliases;
+    }
+    getAssets() {
+        return this._assets;
+    }
+    getAssetByName(name) {
+        return this._assetbyName.get(name);
+    }
+    _cacheData() {
+        const assets = this.querySelectorAll(`assets asset`);
+        const aliases = this.querySelectorAll(`aliases alias`);
+        for (const asset of assets) {
+            const offsetParam = asset.querySelector(`param[key="offset"]`);
+            const value = offsetParam === null || offsetParam === void 0 ? void 0 : offsetParam.getAttribute("value");
+            const name = asset.getAttribute("name");
+            if (value != null && name != null) {
+                const offsets = value.split(",");
+                const x = Number(offsets[0]);
+                const y = Number(offsets[1]);
+                const asset = { name, x, y, flipH: false, flipV: false };
+                this._assets.push(asset);
+                this._assetbyName.set(name, asset);
+            }
+        }
+        for (const alias of aliases) {
+            const name = alias.getAttribute("name");
+            const link = alias.getAttribute("link");
+            const fliph = alias.getAttribute("fliph") === "1";
+            const flipv = alias.getAttribute("flipv") === "1";
+            if (name != null && link != null) {
+                const alias = {
+                    name,
+                    link,
+                    fliph,
+                    flipv,
+                };
+                this._aliases.push(alias);
+            }
+        }
+    }
+}
+exports.AvatarManifestData = AvatarManifestData;

package/dist/objects/avatar/data/AvatarOffsetsData.d.ts

@@ -0,0 +1,10 @@
+import { IAvatarOffsetsData } from "./interfaces/IAvatarOffsetsData";
+export declare class AvatarOffsetsData implements IAvatarOffsetsData {
+    private _json;
+    constructor(_json: any);
+    static fromUrl(url: string): Promise<AvatarOffsetsData>;
+    getOffsets(fileName: string): {
+        offsetX: number;
+        offsetY: number;
+    } | undefined;
+}

package/dist/objects/avatar/data/AvatarOffsetsData.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarOffsetsData = void 0;
+class AvatarOffsetsData {
+    constructor(_json) {
+        this._json = _json;
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const json = await response.json();
+        return new AvatarOffsetsData(json);
+    }
+    getOffsets(fileName) {
+        return this._json[fileName];
+    }
+}
+exports.AvatarOffsetsData = AvatarOffsetsData;

package/dist/objects/avatar/data/AvatarPartSetsData.d.ts

@@ -0,0 +1,12 @@
+import { AvatarData } from "./AvatarData";
+import { IAvatarPartSetsData } from "./interfaces/IAvatarPartSetsData";
+export declare class AvatarPartSetsData extends AvatarData implements IAvatarPartSetsData {
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<AvatarPartSetsData>;
+    static default(): AvatarPartSetsData;
+    getPartInfo(id: string): {
+        removeSetType?: string | undefined;
+        flippedSetType?: string | undefined;
+    } | undefined;
+    getActivePartSet(id: string): Set<string>;
+}

package/dist/objects/avatar/data/AvatarPartSetsData.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarPartSetsData = void 0;
+const AvatarData_1 = require("./AvatarData");
+const partsets_xml_1 = require("./static/partsets.xml");
+class AvatarPartSetsData extends AvatarData_1.AvatarData {
+    constructor(xml) {
+        super(xml);
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new AvatarPartSetsData(text);
+    }
+    static default() {
+        return new AvatarPartSetsData(atob(partsets_xml_1.partsetsXml));
+    }
+    getPartInfo(id) {
+        var _a, _b;
+        const element = this.querySelector(`partSet part[set-type="${id}"]`);
+        if (element == null)
+            return;
+        return {
+            flippedSetType: (_a = element.getAttribute("flipped-set-type")) !== null && _a !== void 0 ? _a : undefined,
+            removeSetType: (_b = element.getAttribute("remove-set-type")) !== null && _b !== void 0 ? _b : undefined,
+        };
+    }
+    getActivePartSet(id) {
+        const partSet = this.querySelectorAll(`activePartSet[id="${id}"] activePart`);
+        return new Set(partSet.map((value) => {
+            const setType = value.getAttribute("set-type");
+            if (setType == null)
+                throw new Error("Invalid set type");
+            return setType;
+        }));
+    }
+}
+exports.AvatarPartSetsData = AvatarPartSetsData;

package/dist/objects/avatar/data/FigureData.d.ts

@@ -0,0 +1,14 @@
+import { AvatarData } from "./AvatarData";
+import { FigureDataPart, IFigureData } from "./interfaces/IFigureData";
+export declare class FigureData extends AvatarData implements IFigureData {
+    private _parts;
+    private _paletteIdForSetType;
+    private _colors;
+    private _hiddenLayers;
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<FigureData>;
+    getColor(setType: string, colorId: string): string | undefined;
+    getParts(setType: string, id: string): FigureDataPart[] | undefined;
+    getHiddenLayers(setType: string, id: string): string[];
+    private _cacheData;
+}

package/dist/objects/avatar/data/FigureData.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FigureData = void 0;
+const AvatarData_1 = require("./AvatarData");
+const _getColorKey = (paletteId, colorId) => {
+    return `${paletteId}_${colorId}`;
+};
+const _getPartsKey = (setType, id) => {
+    return `${setType}_${id}`;
+};
+class FigureData extends AvatarData_1.AvatarData {
+    constructor(xml) {
+        super(xml);
+        this._parts = new Map();
+        this._paletteIdForSetType = new Map();
+        this._colors = new Map();
+        this._hiddenLayers = new Map();
+        this._cacheData();
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        const text = await response.text();
+        return new FigureData(text);
+    }
+    getColor(setType, colorId) {
+        const paletteId = this._paletteIdForSetType.get(setType);
+        if (paletteId == null)
+            return;
+        return this._colors.get(_getColorKey(paletteId, colorId));
+    }
+    getParts(setType, id) {
+        return this._parts.get(_getPartsKey(setType, id));
+    }
+    getHiddenLayers(setType, id) {
+        var _a;
+        return (_a = this._hiddenLayers.get(_getPartsKey(setType, id))) !== null && _a !== void 0 ? _a : [];
+    }
+    _cacheData() {
+        const setTypes = this.querySelectorAll("sets settype");
+        const palettes = this.querySelectorAll("colors palette");
+        palettes.forEach((palette) => {
+            const paletteId = palette.getAttribute("id");
+            if (paletteId == null)
+                return;
+            const colors = Array.from(palette.querySelectorAll("color"));
+            colors.forEach((color) => {
+                const colorId = color.getAttribute("id");
+                if (colorId != null) {
+                    this._colors.set(_getColorKey(paletteId, colorId), color.innerHTML);
+                }
+            });
+        });
+        setTypes.forEach((element) => {
+            const setType = element.getAttribute("type");
+            const paletteId = element.getAttribute("paletteid");
+            const sets = this.querySelectorAll("set");
+            if (setType == null)
+                return;
+            if (paletteId != null) {
+                this._paletteIdForSetType.set(setType, paletteId);
+            }
+            sets.forEach((set) => {
+                const setId = set.getAttribute("id");
+                if (setId == null)
+                    return;
+                const parts = Array.from(set.querySelectorAll("part"));
+                const partArr = [];
+                const hiddenLayers = [];
+                set
+                    .querySelectorAll(`hiddenlayers layer`)
+                    .forEach((hiddenLayerElement) => {
+                    const partType = hiddenLayerElement.getAttribute("parttype");
+                    if (partType != null) {
+                        hiddenLayers.push(partType);
+                    }
+                });
+                this._hiddenLayers.set(_getPartsKey(setType, setId), hiddenLayers);
+                parts
+                    .map((part) => {
+                    const id = part.getAttribute("id");
+                    const type = part.getAttribute("type");
+                    const colorable = part.getAttribute("colorable");
+                    let index = Number(part.getAttribute("index"));
+                    if (isNaN(index)) {
+                        index = 0;
+                    }
+                    if (id == null)
+                        throw new Error("Invalid id");
+                    if (type == null)
+                        throw new Error("Invalid type");
+                    return {
+                        id,
+                        type,
+                        colorable: colorable === "1" ? true : false,
+                        index,
+                    };
+                })
+                    .forEach((part) => {
+                    partArr.push(part);
+                });
+                this._parts.set(_getPartsKey(setType, setId), partArr);
+            });
+        });
+    }
+}
+exports.FigureData = FigureData;

package/dist/objects/avatar/data/FigureMapData.d.ts

@@ -0,0 +1,11 @@
+import { AvatarData } from "./AvatarData";
+import { IFigureMapData } from "./interfaces/IFigureMapData";
+export declare class FigureMapData extends AvatarData implements IFigureMapData {
+    private _libraryForPartMap;
+    private _allLibraries;
+    constructor(xml: string);
+    static fromUrl(url: string): Promise<FigureMapData>;
+    getLibraryOfPart(id: string, type: string): string | undefined;
+    getLibraries(): string[];
+    private _cacheData;
+}