@safe-engine/pixi 8.8.2 → 8.8.3

package/dist/dragonbones/dragonBones/model/TextureAtlasData.js

@@ -0,0 +1,102 @@
+import { BaseObject } from "../core/BaseObject";
+import { Rectangle } from "../geom/Rectangle";
+/**
+ * - The texture atlas data.
+ * @version DragonBones 3.0
+ * @language en_US
+ */
+export class TextureAtlasData extends BaseObject {
+    constructor() {
+        super(...arguments);
+        /**
+         * @private
+         */
+        this.textures = {};
+    }
+    _onClear() {
+        for (let k in this.textures) {
+            this.textures[k].returnToPool();
+            delete this.textures[k];
+        }
+        this.autoSearch = false;
+        this.width = 0;
+        this.height = 0;
+        this.scale = 1.0;
+        // this.textures.clear();
+        this.name = "";
+        this.imagePath = "";
+    }
+    /**
+     * @private
+     */
+    copyFrom(value) {
+        this.autoSearch = value.autoSearch;
+        this.scale = value.scale;
+        this.width = value.width;
+        this.height = value.height;
+        this.name = value.name;
+        this.imagePath = value.imagePath;
+        for (let k in this.textures) {
+            this.textures[k].returnToPool();
+            delete this.textures[k];
+        }
+        // this.textures.clear();
+        for (let k in value.textures) {
+            const texture = this.createTexture();
+            texture.copyFrom(value.textures[k]);
+            this.textures[k] = texture;
+        }
+    }
+    /**
+     * @internal
+     */
+    addTexture(value) {
+        if (value.name in this.textures) {
+            console.warn("Same texture: " + value.name);
+            return;
+        }
+        value.parent = this;
+        this.textures[value.name] = value;
+    }
+    /**
+     * @private
+     */
+    getTexture(textureName) {
+        return textureName in this.textures ? this.textures[textureName] : null;
+    }
+}
+/**
+ * @private
+ */
+export class TextureData extends BaseObject {
+    constructor() {
+        super(...arguments);
+        this.region = new Rectangle();
+        this.frame = null; // Initial value.
+    }
+    static createRectangle() {
+        return new Rectangle();
+    }
+    _onClear() {
+        this.rotated = false;
+        this.name = "";
+        this.region.clear();
+        this.parent = null; //
+        this.frame = null;
+    }
+    copyFrom(value) {
+        this.rotated = value.rotated;
+        this.name = value.name;
+        this.region.copyFrom(value.region);
+        this.parent = value.parent;
+        if (this.frame === null && value.frame !== null) {
+            this.frame = TextureData.createRectangle();
+        }
+        else if (this.frame !== null && value.frame === null) {
+            this.frame = null;
+        }
+        if (this.frame !== null && value.frame !== null) {
+            this.frame.copyFrom(value.frame);
+        }
+    }
+}

package/dist/dragonbones/dragonBones/model/UserData.d.ts

@@ -0,0 +1,73 @@
+import { BaseObject } from "../core/BaseObject";
+import { ActionType } from "../core/DragonBones";
+import { BoneData, SlotData } from "./ArmatureData";
+/**
+ * - The user custom data.
+ * @version DragonBones 5.0
+ * @language en_US
+ */
+export declare class UserData extends BaseObject {
+    static toString(): string;
+    /**
+     * - The custom int numbers.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    readonly ints: Array<number>;
+    /**
+     * - The custom float numbers.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    readonly floats: Array<number>;
+    /**
+     * - The custom strings.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    readonly strings: Array<string>;
+    protected _onClear(): void;
+    /**
+     * @internal
+     */
+    addInt(value: number): void;
+    /**
+     * @internal
+     */
+    addFloat(value: number): void;
+    /**
+     * @internal
+     */
+    addString(value: string): void;
+    /**
+     * - Get the custom int number.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    getInt(index?: number): number;
+    /**
+     * - Get the custom float number.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    getFloat(index?: number): number;
+    /**
+     * - Get the custom string.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    getString(index?: number): string;
+}
+/**
+ * @private
+ */
+export declare class ActionData extends BaseObject {
+    static toString(): string;
+    type: ActionType;
+    name: string;
+    bone: BoneData | null;
+    slot: SlotData | null;
+    data: UserData | null;
+    protected _onClear(): void;
+}
+//# sourceMappingURL=UserData.d.ts.map

package/dist/dragonbones/dragonBones/model/UserData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserData.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/model/UserData.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,QAAS,SAAQ,UAAU;WACxB,QAAQ,IAAI,MAAM;IAGhC;;;;OAIG;IACH,SAAgB,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAM;IACzC;;;;OAIG;IACH,SAAgB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAM;IAC3C;;;;OAIG;IACH,SAAgB,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAM;IAE5C,SAAS,CAAC,QAAQ,IAAI,IAAI;IAK1B;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGlC;;OAEG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGpC;;OAEG;IACI,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGrC;;;;OAIG;IACI,MAAM,CAAC,KAAK,GAAE,MAAU,GAAG,MAAM;IAGxC;;;;OAIG;IACI,QAAQ,CAAC,KAAK,GAAE,MAAU,GAAG,MAAM;IAG1C;;;;OAIG;IACI,SAAS,CAAC,KAAK,GAAE,MAAU,GAAG,MAAM;CAG5C;AACD;;GAEG;AACH,qBAAa,UAAW,SAAQ,UAAU;WAC1B,QAAQ,IAAI,MAAM;IAIzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAQ;IAEpC,SAAS,CAAC,QAAQ,IAAI,IAAI;CAW3B"}

package/dist/dragonbones/dragonBones/model/UserData.js

@@ -0,0 +1,101 @@
+import { BaseObject } from "../core/BaseObject";
+/**
+ * - The user custom data.
+ * @version DragonBones 5.0
+ * @language en_US
+ */
+export class UserData extends BaseObject {
+    constructor() {
+        super(...arguments);
+        /**
+         * - The custom int numbers.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        this.ints = [];
+        /**
+         * - The custom float numbers.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        this.floats = [];
+        /**
+         * - The custom strings.
+         * @version DragonBones 5.0
+         * @language en_US
+         */
+        this.strings = [];
+    }
+    static toString() {
+        return "[class dragonBones.UserData]";
+    }
+    _onClear() {
+        this.ints.length = 0;
+        this.floats.length = 0;
+        this.strings.length = 0;
+    }
+    /**
+     * @internal
+     */
+    addInt(value) {
+        this.ints.push(value);
+    }
+    /**
+     * @internal
+     */
+    addFloat(value) {
+        this.floats.push(value);
+    }
+    /**
+     * @internal
+     */
+    addString(value) {
+        this.strings.push(value);
+    }
+    /**
+     * - Get the custom int number.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    getInt(index = 0) {
+        return index >= 0 && index < this.ints.length ? this.ints[index] : 0;
+    }
+    /**
+     * - Get the custom float number.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    getFloat(index = 0) {
+        return index >= 0 && index < this.floats.length ? this.floats[index] : 0.0;
+    }
+    /**
+     * - Get the custom string.
+     * @version DragonBones 5.0
+     * @language en_US
+     */
+    getString(index = 0) {
+        return index >= 0 && index < this.strings.length ? this.strings[index] : "";
+    }
+}
+/**
+ * @private
+ */
+export class ActionData extends BaseObject {
+    constructor() {
+        super(...arguments);
+        this.data = null; //
+    }
+    static toString() {
+        return "[class dragonBones.ActionData]";
+    }
+    _onClear() {
+        if (this.data !== null) {
+            this.data.returnToPool();
+        }
+        this.type = 0 /* ActionType.Play */;
+        this.name = "";
+        this.bone = null;
+        this.slot = null;
+        this.data = null;
+    }
+}

package/dist/dragonbones/dragonBones/parser/BinaryDataParser.d.ts

@@ -0,0 +1,29 @@
+import { AnimationData } from "../model/AnimationData";
+import { GeometryData } from "../model/DisplayData";
+import { DragonBonesData } from "../model/DragonBonesData";
+import { ObjectDataParser } from "./ObjectDataParser";
+/**
+ * @private
+ */
+export declare class BinaryDataParser extends ObjectDataParser {
+    private _binaryOffset;
+    private _binary;
+    private _intArrayBuffer;
+    private _frameArrayBuffer;
+    private _timelineArrayBuffer;
+    private _inRange;
+    private _decodeUTF8;
+    private _parseBinaryTimeline;
+    protected _parseAnimation(rawData: any): AnimationData;
+    protected _parseGeometry(rawData: any, geometry: GeometryData): void;
+    protected _parseArray(rawData: any): void;
+    parseDragonBonesData(rawData: any, scale?: number): DragonBonesData | null;
+    private static _binaryDataParserInstance;
+    /**
+     * - Deprecated, please refer to {@link dragonBones.BaseFactory#parseDragonBonesData()}.
+     * @deprecated
+     * @language en_US
+     */
+    static getInstance(): BinaryDataParser;
+}
+//# sourceMappingURL=BinaryDataParser.d.ts.map

package/dist/dragonbones/dragonBones/parser/BinaryDataParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryDataParser.d.ts","sourceRoot":"","sources":["../../../../src/dragonbones/dragonBones/parser/BinaryDataParser.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAuC,MAAM,wBAAwB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAc,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,gBAAgB;IACpD,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,oBAAoB,CAAc;IAE1C,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;IA4FnB,OAAO,CAAC,oBAAoB;IAiE5B,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,GAAG,GAAG,aAAa;IAiNtD,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAsCpE,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IA0DlC,oBAAoB,CACzB,OAAO,EAAE,GAAG,EACZ,KAAK,GAAE,MAAU,GAChB,eAAe,GAAG,IAAI;IA8BzB,OAAO,CAAC,MAAM,CAAC,yBAAyB,CAAiC;IACzE;;;;OAIG;WACW,WAAW,IAAI,gBAAgB;CAO9C"}

package/dist/dragonbones/dragonBones/parser/BinaryDataParser.js

@@ -0,0 +1,356 @@
+import { BaseObject } from "../core/BaseObject";
+import { AnimationData, AnimationTimelineData, TimelineData } from "../model/AnimationData";
+import { WeightData } from "../model/DisplayData";
+import { DataParser } from "./DataParser";
+import { ObjectDataParser } from "./ObjectDataParser";
+/**
+ * @private
+ */
+export class BinaryDataParser extends ObjectDataParser {
+    _inRange(a, min, max) {
+        return min <= a && a <= max;
+    }
+    _decodeUTF8(data) {
+        const EOF_byte = -1;
+        const EOF_code_point = -1;
+        const FATAL_POINT = 0xfffd;
+        let pos = 0;
+        let result = "";
+        let code_point;
+        let utf8_code_point = 0;
+        let utf8_bytes_needed = 0;
+        let utf8_bytes_seen = 0;
+        let utf8_lower_boundary = 0;
+        while (data.length > pos) {
+            let _byte = data[pos++];
+            if (_byte === EOF_byte) {
+                if (utf8_bytes_needed !== 0) {
+                    code_point = FATAL_POINT;
+                }
+                else {
+                    code_point = EOF_code_point;
+                }
+            }
+            else {
+                if (utf8_bytes_needed === 0) {
+                    if (this._inRange(_byte, 0x00, 0x7f)) {
+                        code_point = _byte;
+                    }
+                    else {
+                        if (this._inRange(_byte, 0xc2, 0xdf)) {
+                            utf8_bytes_needed = 1;
+                            utf8_lower_boundary = 0x80;
+                            utf8_code_point = _byte - 0xc0;
+                        }
+                        else if (this._inRange(_byte, 0xe0, 0xef)) {
+                            utf8_bytes_needed = 2;
+                            utf8_lower_boundary = 0x800;
+                            utf8_code_point = _byte - 0xe0;
+                        }
+                        else if (this._inRange(_byte, 0xf0, 0xf4)) {
+                            utf8_bytes_needed = 3;
+                            utf8_lower_boundary = 0x10000;
+                            utf8_code_point = _byte - 0xf0;
+                        }
+                        else {
+                        }
+                        utf8_code_point = utf8_code_point * Math.pow(64, utf8_bytes_needed);
+                        code_point = null;
+                    }
+                }
+                else if (!this._inRange(_byte, 0x80, 0xbf)) {
+                    utf8_code_point = 0;
+                    utf8_bytes_needed = 0;
+                    utf8_bytes_seen = 0;
+                    utf8_lower_boundary = 0;
+                    pos--;
+                    code_point = _byte;
+                }
+                else {
+                    utf8_bytes_seen += 1;
+                    utf8_code_point =
+                        utf8_code_point +
+                            (_byte - 0x80) * Math.pow(64, utf8_bytes_needed - utf8_bytes_seen);
+                    if (utf8_bytes_seen !== utf8_bytes_needed) {
+                        code_point = null;
+                    }
+                    else {
+                        let cp = utf8_code_point;
+                        let lower_boundary = utf8_lower_boundary;
+                        utf8_code_point = 0;
+                        utf8_bytes_needed = 0;
+                        utf8_bytes_seen = 0;
+                        utf8_lower_boundary = 0;
+                        if (this._inRange(cp, lower_boundary, 0x10ffff) &&
+                            !this._inRange(cp, 0xd800, 0xdfff)) {
+                            code_point = cp;
+                        }
+                        else {
+                            code_point = _byte;
+                        }
+                    }
+                }
+            }
+            //Decode string
+            if (code_point !== null && code_point !== EOF_code_point) {
+                if (code_point <= 0xffff) {
+                    if (code_point > 0)
+                        result += String.fromCharCode(code_point);
+                }
+                else {
+                    code_point -= 0x10000;
+                    result += String.fromCharCode(0xd800 + ((code_point >> 10) & 0x3ff));
+                    result += String.fromCharCode(0xdc00 + (code_point & 0x3ff));
+                }
+            }
+        }
+        return result;
+    }
+    _parseBinaryTimeline(type, offset, timelineData = null) {
+        const timeline = timelineData !== null
+            ? timelineData
+            : BaseObject.borrowObject(TimelineData);
+        timeline.type = type;
+        timeline.offset = offset;
+        this._timeline = timeline;
+        const keyFrameCount = this._timelineArrayBuffer[timeline.offset + 2 /* BinaryOffset.TimelineKeyFrameCount */];
+        if (keyFrameCount === 1) {
+            timeline.frameIndicesOffset = -1;
+        }
+        else {
+            let frameIndicesOffset = 0;
+            const totalFrameCount = this._animation.frameCount + 1; // One more frame than animation.
+            const frameIndices = this._data.frameIndices;
+            frameIndicesOffset = frameIndices.length;
+            frameIndices.length += totalFrameCount;
+            timeline.frameIndicesOffset = frameIndicesOffset;
+            for (let i = 0, iK = 0, frameStart = 0, frameCount = 0; i < totalFrameCount; ++i) {
+                if (frameStart + frameCount <= i && iK < keyFrameCount) {
+                    frameStart =
+                        this._frameArrayBuffer[this._animation.frameOffset +
+                            this._timelineArrayBuffer[timeline.offset + 5 /* BinaryOffset.TimelineFrameOffset */ + iK]];
+                    if (iK === keyFrameCount - 1) {
+                        frameCount = this._animation.frameCount - frameStart;
+                    }
+                    else {
+                        frameCount =
+                            this._frameArrayBuffer[this._animation.frameOffset +
+                                this._timelineArrayBuffer[timeline.offset + 5 /* BinaryOffset.TimelineFrameOffset */ + iK + 1]] - frameStart;
+                    }
+                    iK++;
+                }
+                frameIndices[frameIndicesOffset + i] = iK - 1;
+            }
+        }
+        this._timeline = null; //
+        return timeline;
+    }
+    _parseAnimation(rawData) {
+        const animation = BaseObject.borrowObject(AnimationData);
+        animation.blendType = DataParser._getAnimationBlendType(ObjectDataParser._getString(rawData, DataParser.BLEND_TYPE, ""));
+        animation.frameCount = ObjectDataParser._getNumber(rawData, DataParser.DURATION, 0);
+        animation.playTimes = ObjectDataParser._getNumber(rawData, DataParser.PLAY_TIMES, 1);
+        animation.duration = animation.frameCount / this._armature.frameRate; // float
+        animation.fadeInTime = ObjectDataParser._getNumber(rawData, DataParser.FADE_IN_TIME, 0.0);
+        animation.scale = ObjectDataParser._getNumber(rawData, DataParser.SCALE, 1.0);
+        animation.name = ObjectDataParser._getString(rawData, DataParser.NAME, DataParser.DEFAULT_NAME);
+        if (animation.name.length === 0) {
+            animation.name = DataParser.DEFAULT_NAME;
+        }
+        // Offsets.
+        const offsets = rawData[DataParser.OFFSET];
+        animation.frameIntOffset = offsets[0];
+        animation.frameFloatOffset = offsets[1];
+        animation.frameOffset = offsets[2];
+        this._animation = animation;
+        if (DataParser.ACTION in rawData) {
+            animation.actionTimeline = this._parseBinaryTimeline(0 /* TimelineType.Action */, rawData[DataParser.ACTION]);
+        }
+        if (DataParser.Z_ORDER in rawData) {
+            animation.zOrderTimeline = this._parseBinaryTimeline(1 /* TimelineType.ZOrder */, rawData[DataParser.Z_ORDER]);
+        }
+        if (DataParser.BONE in rawData) {
+            const rawTimeliness = rawData[DataParser.BONE];
+            for (let k in rawTimeliness) {
+                const rawTimelines = rawTimeliness[k];
+                const bone = this._armature.getBone(k);
+                if (bone === null) {
+                    continue;
+                }
+                for (let i = 0, l = rawTimelines.length; i < l; i += 2) {
+                    const timelineType = rawTimelines[i];
+                    const timelineOffset = rawTimelines[i + 1];
+                    const timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                    this._animation.addBoneTimeline(bone.name, timeline);
+                }
+            }
+        }
+        if (DataParser.SLOT in rawData) {
+            const rawTimeliness = rawData[DataParser.SLOT];
+            for (let k in rawTimeliness) {
+                const rawTimelines = rawTimeliness[k];
+                const slot = this._armature.getSlot(k);
+                if (slot === null) {
+                    continue;
+                }
+                for (let i = 0, l = rawTimelines.length; i < l; i += 2) {
+                    const timelineType = rawTimelines[i];
+                    const timelineOffset = rawTimelines[i + 1];
+                    const timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                    this._animation.addSlotTimeline(slot.name, timeline);
+                }
+            }
+        }
+        if (DataParser.CONSTRAINT in rawData) {
+            const rawTimeliness = rawData[DataParser.CONSTRAINT];
+            for (let k in rawTimeliness) {
+                const rawTimelines = rawTimeliness[k];
+                const constraint = this._armature.getConstraint(k);
+                if (constraint === null) {
+                    continue;
+                }
+                for (let i = 0, l = rawTimelines.length; i < l; i += 2) {
+                    const timelineType = rawTimelines[i];
+                    const timelineOffset = rawTimelines[i + 1];
+                    const timeline = this._parseBinaryTimeline(timelineType, timelineOffset);
+                    this._animation.addConstraintTimeline(constraint.name, timeline);
+                }
+            }
+        }
+        if (DataParser.TIMELINE in rawData) {
+            const rawTimelines = rawData[DataParser.TIMELINE];
+            for (const rawTimeline of rawTimelines) {
+                const timelineOffset = ObjectDataParser._getNumber(rawTimeline, DataParser.OFFSET, 0);
+                if (timelineOffset >= 0) {
+                    const timelineType = ObjectDataParser._getNumber(rawTimeline, DataParser.TYPE, 0 /* TimelineType.Action */);
+                    const timelineName = ObjectDataParser._getString(rawTimeline, DataParser.NAME, "");
+                    let timeline = null;
+                    if (timelineType === 40 /* TimelineType.AnimationProgress */ &&
+                        animation.blendType !== 0 /* AnimationBlendType.None */) {
+                        timeline = BaseObject.borrowObject(AnimationTimelineData);
+                        const animaitonTimeline = timeline;
+                        animaitonTimeline.x = ObjectDataParser._getNumber(rawTimeline, DataParser.X, 0.0);
+                        animaitonTimeline.y = ObjectDataParser._getNumber(rawTimeline, DataParser.Y, 0.0);
+                    }
+                    timeline = this._parseBinaryTimeline(timelineType, timelineOffset, timeline);
+                    switch (timelineType) {
+                        case 0 /* TimelineType.Action */:
+                            // TODO
+                            break;
+                        case 1 /* TimelineType.ZOrder */:
+                            // TODO
+                            break;
+                        case 11 /* TimelineType.BoneTranslate */:
+                        case 12 /* TimelineType.BoneRotate */:
+                        case 13 /* TimelineType.BoneScale */:
+                        case 50 /* TimelineType.Surface */:
+                        case 60 /* TimelineType.BoneAlpha */:
+                            this._animation.addBoneTimeline(timelineName, timeline);
+                            break;
+                        case 20 /* TimelineType.SlotDisplay */:
+                        case 21 /* TimelineType.SlotColor */:
+                        case 22 /* TimelineType.SlotDeform */:
+                        case 23 /* TimelineType.SlotZIndex */:
+                        case 24 /* TimelineType.SlotAlpha */:
+                            this._animation.addSlotTimeline(timelineName, timeline);
+                            break;
+                        case 30 /* TimelineType.IKConstraint */:
+                            this._animation.addConstraintTimeline(timelineName, timeline);
+                            break;
+                        case 40 /* TimelineType.AnimationProgress */:
+                        case 41 /* TimelineType.AnimationWeight */:
+                        case 42 /* TimelineType.AnimationParameter */:
+                            this._animation.addAnimationTimeline(timelineName, timeline);
+                            break;
+                    }
+                }
+            }
+        }
+        this._animation = null;
+        return animation;
+    }
+    _parseGeometry(rawData, geometry) {
+        geometry.offset = rawData[DataParser.OFFSET];
+        geometry.data = this._data;
+        const weightOffset = this._intArrayBuffer[geometry.offset + 3 /* BinaryOffset.GeometryWeightOffset */];
+        if (weightOffset >= 0) {
+            const weight = BaseObject.borrowObject(WeightData);
+            const vertexCount = this._intArrayBuffer[geometry.offset + 0 /* BinaryOffset.GeometryVertexCount */];
+            const boneCount = this._intArrayBuffer[weightOffset + 0 /* BinaryOffset.WeigthBoneCount */];
+            weight.offset = weightOffset;
+            for (let i = 0; i < boneCount; ++i) {
+                const boneIndex = this._intArrayBuffer[weightOffset + 2 /* BinaryOffset.WeigthBoneIndices */ + i];
+                weight.addBone(this._rawBones[boneIndex]);
+            }
+            let boneIndicesOffset = weightOffset + 2 /* BinaryOffset.WeigthBoneIndices */ + boneCount;
+            let weightCount = 0;
+            for (let i = 0, l = vertexCount; i < l; ++i) {
+                const vertexBoneCount = this._intArrayBuffer[boneIndicesOffset++];
+                weightCount += vertexBoneCount;
+                boneIndicesOffset += vertexBoneCount;
+            }
+            weight.count = weightCount;
+            geometry.weight = weight;
+        }
+    }
+    _parseArray(rawData) {
+        const offsets = rawData[DataParser.OFFSET];
+        const l1 = offsets[1];
+        const l2 = offsets[3];
+        const l3 = offsets[5];
+        const l4 = offsets[7];
+        const l5 = offsets[9];
+        const l6 = offsets[11];
+        const l7 = offsets.length > 12 ? offsets[13] : 0; // Color.
+        const intArray = new Uint16Array(this._binary, this._binaryOffset + offsets[0], l1 / Uint16Array.BYTES_PER_ELEMENT);
+        const floatArray = new Float32Array(this._binary, this._binaryOffset + offsets[2], l2 / Float32Array.BYTES_PER_ELEMENT);
+        const frameIntArray = new Int16Array(this._binary, this._binaryOffset + offsets[4], l3 / Int16Array.BYTES_PER_ELEMENT);
+        const frameFloatArray = new Float32Array(this._binary, this._binaryOffset + offsets[6], l4 / Float32Array.BYTES_PER_ELEMENT);
+        const frameArray = new Int16Array(this._binary, this._binaryOffset + offsets[8], l5 / Int16Array.BYTES_PER_ELEMENT);
+        const timelineArray = new Uint16Array(this._binary, this._binaryOffset + offsets[10], l6 / Uint16Array.BYTES_PER_ELEMENT);
+        const colorArray = l7 > 0
+            ? new Uint16Array(this._binary, this._binaryOffset + offsets[12], l7 / Uint16Array.BYTES_PER_ELEMENT)
+            : intArray; // Color.
+        this._data.binary = this._binary;
+        this._data.intArray = this._intArrayBuffer = intArray;
+        this._data.floatArray = floatArray;
+        this._data.frameIntArray = frameIntArray;
+        this._data.frameFloatArray = frameFloatArray;
+        this._data.frameArray = this._frameArrayBuffer = frameArray;
+        this._data.timelineArray = this._timelineArrayBuffer = timelineArray;
+        this._data.colorArray = colorArray;
+    }
+    parseDragonBonesData(rawData, scale = 1) {
+        console.assert(rawData !== null &&
+            rawData !== undefined &&
+            rawData instanceof ArrayBuffer, "Data error.");
+        const tag = new Uint8Array(rawData, 0, 8);
+        if (tag[0] !== "D".charCodeAt(0) ||
+            tag[1] !== "B".charCodeAt(0) ||
+            tag[2] !== "D".charCodeAt(0) ||
+            tag[3] !== "T".charCodeAt(0)) {
+            console.assert(false, "Nonsupport data.");
+            return null;
+        }
+        const headerLength = new Uint32Array(rawData, 8, 1)[0];
+        const headerBytes = new Uint8Array(rawData, 8 + 4, headerLength);
+        const headerString = this._decodeUTF8(headerBytes);
+        const header = JSON.parse(headerString);
+        //
+        this._binaryOffset = 8 + 4 + headerLength;
+        this._binary = rawData;
+        return super.parseDragonBonesData(header, scale);
+    }
+    /**
+     * - Deprecated, please refer to {@link dragonBones.BaseFactory#parseDragonBonesData()}.
+     * @deprecated
+     * @language en_US
+     */
+    static getInstance() {
+        if (BinaryDataParser._binaryDataParserInstance === null) {
+            BinaryDataParser._binaryDataParserInstance = new BinaryDataParser();
+        }
+        return BinaryDataParser._binaryDataParserInstance;
+    }
+}
+BinaryDataParser._binaryDataParserInstance = null;