/****************************************************************************
 Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.

 https://www.cocos.com/

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated engine source code (the "Software"), a limited,
 worldwide, royalty-free, non-assignable, revocable and non-exclusive license
 to use Cocos Creator solely to develop games on your target platforms. You shall
 not use Cocos Creator software for developing other software or tools that's
 used for developing games. You are not granted to publish, distribute,
 sublicense, and/or sell copies of Cocos Creator.

 The software or tools in this License Agreement are licensed, not sold.
 Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ****************************************************************************/

const Skeleton = require('./Skeleton');
const spine = require('./lib/spine');
const renderer = require('../../cocos2d/core/renderer');
const RenderFlow = require('../../cocos2d/core/renderer/render-flow');
const renderEngine = renderer.renderEngine;
const gfx = renderEngine.gfx;
const VertexFormat = require('../../cocos2d/core/renderer/webgl/vertex-format')
const VFOneColor = VertexFormat.vfmtPosUvColor;
const VFTwoColor = VertexFormat.vfmtPosUvTwoColor;

const FLAG_BATCH = 0x10;
const FLAG_TWO_COLOR = 0x01;
const NOT_BATCH_ONE_COLOR = 0x00;
const NOT_BATCH_TWO_COLOR = 0x01;
const BATCH_ONE_COLOR = 0x10;
const BATCH_TWO_COLOR = 0x11;

let _handleVal = 0x00;
let _quadTriangles = [0, 1, 2, 2, 3, 0];
let _slotColor = cc.color(0, 0, 255, 255);
let _boneColor = cc.color(255, 0, 0, 255);
let _originColor = cc.color(0, 255, 0, 255);

let _finalColor = undefined;
let _darkColor = undefined;
if (!CC_JSB) {
    _finalColor = new spine.Color(1, 1, 1, 1);
    _darkColor = new spine.Color(1, 1, 1, 1);
}

let _premultipliedAlpha;
let _multiplier;
let _slotRangeStart;
let _slotRangeEnd;
let _useTint;
let _debugSlots;
let _debugBones;
let _nodeR,
    _nodeG,
    _nodeB,
    _nodeA;
let _finalColor32, _darkColor32;
let _vertexFormat;
let _perVertexSize;
let _perClipVertexSize;
let _vertexFloatCount = 0, _vertexCount = 0, _vertexFloatOffset = 0, _vertexOffset = 0,
    _indexCount = 0, _indexOffset = 0, _vfOffset = 0;
let _tempr, _tempg, _tempb, _tempa;
let _inRange;
let _mustFlush;
let _x, _y, _m00, _m04, _m12, _m01, _m05, _m13;
let _r, _g, _b, _fr, _fg, _fb, _fa, _dr, _dg, _db, _da;
let _comp, _buffer, _renderer, _node, _needColor;

function _getSlotMaterial (tex, blendMode) {
    let src, dst;
    switch (blendMode) {
        case spine.BlendMode.Additive:
            src = _premultipliedAlpha ? cc.macro.ONE : cc.macro.SRC_ALPHA;
            dst = cc.macro.ONE;
            break;
        case spine.BlendMode.Multiply:
            src = cc.macro.DST_COLOR;
            dst = cc.macro.ONE_MINUS_SRC_ALPHA;
            break;
        case spine.BlendMode.Screen:
            src = cc.macro.ONE;
            dst = cc.macro.ONE_MINUS_SRC_COLOR;
            break;
        case spine.BlendMode.Normal:
        default:
            src = _premultipliedAlpha ? cc.macro.ONE : cc.macro.SRC_ALPHA;
            dst = cc.macro.ONE_MINUS_SRC_ALPHA;
            break;
    }

    let useModel = !_comp.enableBatch;
    let key = tex.url + src + dst + _useTint + useModel;
    let baseMaterial = _comp._material;
    if (!baseMaterial) return null;

    let materialCache = _comp._materialCache;
    let material = materialCache[key];
    if (!material) {

        var baseKey = baseMaterial._hash;
        if (!materialCache[baseKey]) {
            material = baseMaterial;
        } else {
            material = baseMaterial.clone();
        }

        material.useModel = useModel;
        // Update texture.
        material.texture = tex;
        // Update tint.
        material.useTint = _useTint;

        // Update blend function.
        let pass = material._mainTech.passes[0];
        pass.setBlend(
            gfx.BLEND_FUNC_ADD,
            src, dst,
            gfx.BLEND_FUNC_ADD,
            src, dst
        );
        material.updateHash(key);
        materialCache[key] = material;
    }
    else if (material.texture !== tex) {
        material.texture = tex;
        material.updateHash(key);
    }
    return material;
}

function _handleColor (color) {
    // temp rgb has multiply 255, so need divide 255;
    _multiplier = _premultipliedAlpha ? color.fa / 255 : 1;
    _r = _nodeR * _multiplier;
    _g = _nodeG * _multiplier;
    _b = _nodeB * _multiplier;

    _fr = color.fr * _r;
    _fg = color.fg * _g;
    _fb = color.fb * _b;
    _fa = color.fa * _nodeA;
    _finalColor32 = ((_fa<<24) >>> 0) + (_fb<<16) + (_fg<<8) + _fr;

    _dr = color.dr * _r;
    _dg = color.dg * _g;
    _db = color.db * _b;
    _da = _premultipliedAlpha ? 255 : 0;
    _darkColor32 = ((_da<<24) >>> 0) + (_db<<16) + (_dg<<8) + _dr;
}

var spineAssembler = {

    updateRenderData (comp, batchData) {
        let skeleton = comp._skeleton;
        if (skeleton) {
            skeleton.updateWorldTransform();
        }
    },

    fillVertices (skeletonColor, attachmentColor, slotColor, clipper, slot) {

        let vbuf = _buffer._vData,
            ibuf = _buffer._iData,
            uintVData = _buffer._uintVData;
        let offsetInfo;

        _tempa = slotColor.a * attachmentColor.a * skeletonColor.a * 255;
        _multiplier = _premultipliedAlpha? _tempa : 255;
        _tempr = _nodeR * attachmentColor.r * skeletonColor.r * _multiplier;
        _tempg = _nodeG * attachmentColor.g * skeletonColor.g * _multiplier;
        _tempb = _nodeB * attachmentColor.b * skeletonColor.b * _multiplier;
        
        _finalColor.r = _tempr * slotColor.r;
        _finalColor.g = _tempg * slotColor.g;
        _finalColor.b = _tempb * slotColor.b;
        _finalColor.a = _tempa * _nodeA;

        if (slot.darkColor == null) {
            _darkColor.set(0.0, 0, 0, 1.0);
        } else {
            _darkColor.r = slot.darkColor.r * _tempr;
            _darkColor.g = slot.darkColor.g * _tempg;
            _darkColor.b = slot.darkColor.b * _tempb;
        }
        _darkColor.a = _premultipliedAlpha ? 255 : 0;

        if (!clipper.isClipping()) {

            _finalColor32 = ((_finalColor.a<<24) >>> 0) + (_finalColor.b<<16) + (_finalColor.g<<8) + _finalColor.r;
            _darkColor32 = ((_darkColor.a<<24) >>> 0) + (_darkColor.b<<16) + (_darkColor.g<<8) + _darkColor.r;

            if (!_useTint) {
                for (let v = _vertexFloatOffset, n = _vertexFloatOffset + _vertexFloatCount; v < n; v += _perVertexSize) {
                    uintVData[v + 4] = _finalColor32;
                }
            } else {
                for (let v = _vertexFloatOffset, n = _vertexFloatOffset + _vertexFloatCount; v < n; v += _perVertexSize) {
                    uintVData[v + 4]  = _finalColor32;     // light color
                    uintVData[v + 5]  = _darkColor32;      // dark color
                }
            }

        } else {
            let uvs = vbuf.subarray(_vertexFloatOffset + 2);
            clipper.clipTriangles(vbuf.subarray(_vertexFloatOffset), _vertexFloatCount, ibuf.subarray(_indexOffset), _indexCount, uvs, _finalColor, _darkColor, _useTint, _perVertexSize);
            let clippedVertices = new Float32Array(clipper.clippedVertices);
            let clippedTriangles = clipper.clippedTriangles;
            
            // insure capacity
            _indexCount = clippedTriangles.length;
            _vertexFloatCount = clippedVertices.length / _perClipVertexSize * _perVertexSize;

            offsetInfo = _buffer.request(_vertexFloatCount / _perVertexSize, _indexCount);
            _indexOffset = offsetInfo.indiceOffset,
            _vertexOffset = offsetInfo.vertexOffset,
            _vertexFloatOffset = offsetInfo.byteOffset >> 2;
            vbuf = _buffer._vData,
            ibuf = _buffer._iData;
            uintVData = _buffer._uintVData;

            // fill indices
            ibuf.set(clippedTriangles, _indexOffset);

            // fill vertices contain x y u v light color dark color
            if (!_useTint) {
                for (let v = 0, n = clippedVertices.length, offset = _vertexFloatOffset; v < n; v += 8, offset += _perVertexSize) {
                    vbuf[offset]     = clippedVertices[v];        // x
                    vbuf[offset + 1] = clippedVertices[v + 1];    // y
                    vbuf[offset + 2] = clippedVertices[v + 6];    // u
                    vbuf[offset + 3] = clippedVertices[v + 7];    // v

                    _finalColor32 = ((clippedVertices[v + 5]<<24) >>> 0) + (clippedVertices[v + 4]<<16) + (clippedVertices[v + 3]<<8) + clippedVertices[v + 2];
                    uintVData[offset + 4] = _finalColor32;
                }
            } else {
                for (let v = 0, n = clippedVertices.length, offset = _vertexFloatOffset; v < n; v += 12, offset += _perVertexSize) {
                    vbuf[offset] = clippedVertices[v];                 // x
                    vbuf[offset + 1] = clippedVertices[v + 1];         // y
                    vbuf[offset + 2] = clippedVertices[v + 6];         // u
                    vbuf[offset + 3] = clippedVertices[v + 7];         // v

                    _finalColor32 = ((clippedVertices[v + 5]<<24) >>> 0) + (clippedVertices[v + 4]<<16) + (clippedVertices[v + 3]<<8) + clippedVertices[v + 2];
                    uintVData[offset + 4] = _finalColor32;

                    _darkColor32 = ((clippedVertices[v + 11]<<24) >>> 0) + (clippedVertices[v + 10]<<16) + (clippedVertices[v + 9]<<8) + clippedVertices[v + 8];
                    uintVData[offset + 5] = _darkColor32;
                }
            }
        }
    },

    realTimeTraverse (worldMat) {
        let vbuf;
        let ibuf;

        let locSkeleton = _comp._skeleton;
        let skeletonColor = locSkeleton.color;
        let graphics = _comp._debugRenderer;
        let clipper = _comp._clipper;
        let material = null;
        let attachment, attachmentColor, slotColor, uvs, triangles;
        let isRegion, isMesh, isClip;
        let offsetInfo;
        let slot;

        _slotRangeStart = _comp._startSlotIndex;
        _slotRangeEnd = _comp._endSlotIndex;
        _inRange = false;
        if (_slotRangeStart == -1) _inRange = true;

        _debugSlots = _comp.debugSlots;
        _debugBones = _comp.debugBones;
        if (graphics && (_debugBones || _debugSlots)) {
            graphics.clear();
            graphics.strokeColor = _slotColor;
            graphics.lineWidth = 5;
        }
    
        // x y u v r1 g1 b1 a1 r2 g2 b2 a2 or x y u v r g b a 
        _perClipVertexSize = _useTint ? 12 : 8;
    
        _vertexFloatCount = 0;
        _vertexFloatOffset = 0;
        _vertexOffset = 0;
        _indexCount = 0;
        _indexOffset = 0;

        for (let slotIdx = 0, slotCount = locSkeleton.drawOrder.length; slotIdx < slotCount; slotIdx++) {
            slot = locSkeleton.drawOrder[slotIdx];
    
            if (_slotRangeStart >= 0 && _slotRangeStart == slot.data.index) {
                _inRange = true;
            }
            
            if (!_inRange) {
                clipper.clipEndWithSlot(slot);
                continue;
            }
    
            if (_slotRangeEnd >= 0 && _slotRangeEnd == slot.data.index) {
                _inRange = false;
            }
    
            _vertexFloatCount = 0;
            _indexCount = 0;

            attachment = slot.getAttachment();
            if (!attachment) continue;

            isRegion = attachment instanceof spine.RegionAttachment;
            isMesh = attachment instanceof spine.MeshAttachment;
            isClip = attachment instanceof spine.ClippingAttachment;

            if (isClip) {
                clipper.clipStart(slot, attachment);
                continue;
            }

            if (!isRegion && !isMesh) continue;

            material = _getSlotMaterial(attachment.region.texture._texture, slot.data.blendMode);
            if (!material) {
                continue;
            }

            if (_mustFlush || material._hash !== _renderer.material._hash) {
                _mustFlush = false;
                _renderer._flush();
                _renderer.node = _node;
                _renderer.material = material;
            }

            if (isRegion) {
                
                triangles = _quadTriangles;
    
                // insure capacity
                _vertexFloatCount = 4 * _perVertexSize;
                _indexCount = 6;

                offsetInfo = _buffer.request(4, 6);
                _indexOffset = offsetInfo.indiceOffset,
                _vertexOffset = offsetInfo.vertexOffset,
                _vertexFloatOffset = offsetInfo.byteOffset >> 2;
                vbuf = _buffer._vData,
                ibuf = _buffer._iData;
    
                // compute vertex and fill x y
                attachment.computeWorldVertices(slot.bone, vbuf, _vertexFloatOffset, _perVertexSize);
    
                // draw debug slots if enabled graphics
                if (graphics && _debugSlots) {
                    graphics.moveTo(vbuf[_vertexFloatOffset], vbuf[_vertexFloatOffset + 1]);
                    for (let ii = _vertexFloatOffset + _perVertexSize, nn = _vertexFloatOffset + _vertexFloatCount; ii < nn; ii += _perVertexSize) {
                        graphics.lineTo(vbuf[ii], vbuf[ii + 1]);
                    }
                    graphics.close();
                    graphics.stroke();
                }
            }
            else if (isMesh) {
                
                triangles = attachment.triangles;
    
                // insure capacity
                _vertexFloatCount = (attachment.worldVerticesLength >> 1) * _perVertexSize;
                _indexCount = triangles.length;

                offsetInfo = _buffer.request(_vertexFloatCount / _perVertexSize, _indexCount);
                _indexOffset = offsetInfo.indiceOffset,
                _vertexOffset = offsetInfo.vertexOffset,
                _vertexFloatOffset = offsetInfo.byteOffset >> 2;
                vbuf = _buffer._vData,
                ibuf = _buffer._iData;
    
                // compute vertex and fill x y
                attachment.computeWorldVertices(slot, 0, attachment.worldVerticesLength, vbuf, _vertexFloatOffset, _perVertexSize);
            }
    
            if (_vertexFloatCount == 0 || _indexCount == 0) {
                continue;
            }
    
            // fill indices
            ibuf.set(triangles, _indexOffset);

            // fill u v
            uvs = attachment.uvs;
            for (let v = _vertexFloatOffset, n = _vertexFloatOffset + _vertexFloatCount, u = 0; v < n; v += _perVertexSize, u += 2) {
                vbuf[v + 2] = uvs[u];           // u
                vbuf[v + 3] = uvs[u + 1];       // v
            }

            attachmentColor = attachment.color,
            slotColor = slot.color;

            this.fillVertices(skeletonColor, attachmentColor, slotColor, clipper, slot);
    
            if (_indexCount > 0) {
                for (let ii = _indexOffset, nn = _indexOffset + _indexCount; ii < nn; ii++) {
                    ibuf[ii] += _vertexOffset;
                }

                if (worldMat) {
                    _m00 = worldMat.m00;
                    _m04 = worldMat.m04;
                    _m12 = worldMat.m12;
                    _m01 = worldMat.m01;
                    _m05 = worldMat.m05;
                    _m13 = worldMat.m13;
                    for (let ii = _vertexFloatOffset, nn = _vertexFloatOffset + _vertexFloatCount; ii < nn; ii += _perVertexSize) {
                        _x = vbuf[ii];
                        _y = vbuf[ii + 1];
                        vbuf[ii] = _x * _m00 + _y * _m04 + _m12;
                        vbuf[ii + 1] = _x * _m01 + _y * _m05 + _m13;
                    }
                }
                _buffer.adjust(_vertexFloatCount / _perVertexSize, _indexCount);
            }
    
            clipper.clipEndWithSlot(slot);
        }
    
        clipper.clipEnd();
    
        if (graphics && _debugBones) {
            let bone;
            graphics.strokeColor = _boneColor;
            graphics.fillColor = _slotColor; // Root bone color is same as slot color.
    
            for (let i = 0, n = locSkeleton.bones.length; i < n; i++) {
                bone = locSkeleton.bones[i];
                let x = bone.data.length * bone.a + bone.worldX;
                let y = bone.data.length * bone.c + bone.worldY;
    
                // Bone lengths.
                graphics.moveTo(bone.worldX, bone.worldY);
                graphics.lineTo(x, y);
                graphics.stroke();
    
                // Bone origins.
                graphics.circle(bone.worldX, bone.worldY, Math.PI * 2);
                graphics.fill();
                if (i === 0) {
                    graphics.fillColor = _originColor;
                }
            }
        }
    },

    cacheTraverse (worldMat) {
        
        let frame = _comp._curFrame;
        if (!frame) return;

        let segments = frame.segments;
        if (segments.length == 0) return;

        let vbuf, ibuf, uintbuf;
        let material;
        let offsetInfo;
        let vertices = frame.vertices;
        let indices = frame.indices;
        let uintVert = frame.uintVert;

        let frameVFOffset = 0, frameIndexOffset = 0, segVFCount = 0;
        if (worldMat) {
            _m00 = worldMat.m00;
            _m04 = worldMat.m04;
            _m12 = worldMat.m12;
            _m01 = worldMat.m01;
            _m05 = worldMat.m05;
            _m13 = worldMat.m13;
        }

        let colorOffset = 0;
        let colors = frame.colors;
        let nowColor = colors[colorOffset++];
        let maxVFOffset = nowColor.vfOffset;
        _handleColor(nowColor);

        for (let i = 0, n = segments.length; i < n; i++) {
            let segInfo = segments[i];
            material = _getSlotMaterial(segInfo.tex, segInfo.blendMode);
            if (!material) continue;

            if (_mustFlush || material._hash !== _renderer.material._hash) {
                _mustFlush = false;
                _renderer._flush();
                _renderer.node = _node;
                _renderer.material = material;
            }

            _vertexCount = segInfo.vertexCount;
            _indexCount = segInfo.indexCount;
            _vertexFloatCount = _vertexCount * _perVertexSize;

            offsetInfo = _buffer.request(_vertexCount, _indexCount);
            _indexOffset = offsetInfo.indiceOffset;
            _vertexOffset = offsetInfo.vertexOffset;
            _vfOffset = offsetInfo.byteOffset >> 2;
            vbuf = _buffer._vData;
            ibuf = _buffer._iData;
            uintbuf = _buffer._uintVData;

            for (let ii = _indexOffset, il = _indexOffset + _indexCount; ii < il; ii++) {
                ibuf[ii] = _vertexOffset + indices[frameIndexOffset++];
            }

            segVFCount = segInfo.vfCount;
            
            switch (_handleVal) {
                case NOT_BATCH_ONE_COLOR:
                    for (let ii = _vfOffset, il = _vfOffset + _vertexFloatCount; ii < il;) {
                        vbuf[ii++] = vertices[frameVFOffset++];  // x
                        vbuf[ii++] = vertices[frameVFOffset++];  // y
                        vbuf[ii++] = vertices[frameVFOffset++];     // u
                        vbuf[ii++] = vertices[frameVFOffset++];     // v
                        uintbuf[ii++] = uintVert[frameVFOffset++];  // final color
                        frameVFOffset++; // jump dark color
                    }
                break;
                case NOT_BATCH_TWO_COLOR:
                    vbuf.set(vertices.subarray(frameVFOffset, frameVFOffset + _vertexFloatCount), _vfOffset);
                    frameVFOffset += _vertexFloatCount;
                break;
                case BATCH_ONE_COLOR:
                    for (let ii = _vfOffset, il = _vfOffset + _vertexFloatCount; ii < il;) {
                        _x = vertices[frameVFOffset++];
                        _y = vertices[frameVFOffset++];
                        vbuf[ii++] = _x * _m00 + _y * _m04 + _m12;  // x
                        vbuf[ii++] = _x * _m01 + _y * _m05 + _m13;  // y
                        vbuf[ii++] = vertices[frameVFOffset++];     // u
                        vbuf[ii++] = vertices[frameVFOffset++];     // v
                        uintbuf[ii++] = uintVert[frameVFOffset++];  // final color
                        frameVFOffset++;                            // dark color
                    }
                break;
                case BATCH_TWO_COLOR:
                    for (let ii = _vfOffset, il = _vfOffset + _vertexFloatCount; ii < il;) {
                        _x = vertices[frameVFOffset++];
                        _y = vertices[frameVFOffset++];
                        vbuf[ii++] = _x * _m00 + _y * _m04 + _m12;  // x
                        vbuf[ii++] = _x * _m01 + _y * _m05 + _m13;  // y
                        vbuf[ii++] = vertices[frameVFOffset++];     // u
                        vbuf[ii++] = vertices[frameVFOffset++];     // v
                        uintbuf[ii++] = uintVert[frameVFOffset++];  // final color
                        uintbuf[ii++] = uintVert[frameVFOffset++];  // dark color
                    }
                break;
            }

            _buffer.adjust(_vertexCount, _indexCount);
            if ( !_needColor ) continue;

            // handle color
            let frameColorOffset = frameVFOffset - segVFCount;
            for (let ii = _vfOffset + 4, il = _vfOffset + 4 + _vertexFloatCount; ii < il; ii += _perVertexSize, frameColorOffset += 6) {
                if (frameColorOffset >= maxVFOffset) {
                    nowColor = colors[colorOffset++];
                    _handleColor(nowColor);
                    maxVFOffset = nowColor.vfOffset;
                }
                uintbuf[ii] = _finalColor32;
                _useTint && (uintbuf[ii + 1] = _darkColor32);
            }
        }
    },

    fillBuffers (comp, renderer) {
        
        let node = comp.node;
        node._renderFlag |= RenderFlow.FLAG_UPDATE_RENDER_DATA;
        if (!comp._skeleton) return;

        let nodeColor = node._color;
        _nodeR = nodeColor.r / 255;
        _nodeG = nodeColor.g / 255;
        _nodeB = nodeColor.b / 255;
        _nodeA = nodeColor.a / 255;

        _useTint = comp.useTint;
        _vertexFormat = _useTint? VFTwoColor : VFOneColor;
        // x y u v color1 color2 or x y u v color
        _perVertexSize = _useTint ? 6 : 5;

        _node = comp.node;
        _buffer = renderer.getBuffer('spine', _vertexFormat);
        _renderer = renderer;
        _comp = comp;

        _mustFlush = true;
        _premultipliedAlpha = comp.premultipliedAlpha;
        _multiplier = 1.0;
        _handleVal = 0x00;
        _needColor = false;

        if (nodeColor._val !== 0xffffffff || _premultipliedAlpha) {
            _needColor = true;
        }

        if (_useTint) {
            _handleVal |= FLAG_TWO_COLOR;
        }

        let worldMat = undefined;
        if (_comp.enableBatch) {
            worldMat = _node._worldMatrix;
            _mustFlush = false;
            _handleVal |= FLAG_BATCH;
        }

        if (comp.isAnimationCached()) {
            // Traverse input assembler.
            this.cacheTraverse(worldMat);
        } else {
            this.realTimeTraverse(worldMat);
        }

        // Clear temp var.
        _node = undefined;
        _buffer = undefined;
        _renderer = undefined;
        _comp = undefined;
    }
};

Skeleton._assembler = spineAssembler;

module.exports = spineAssembler;