feat: Add Be and tbd skill, also added Roadmap file

Skills/@be/be/node_modules/pixi-animate/lib/mixins/Container.js

@@ -0,0 +1,38 @@
+"use strict";
+
+/**
+ * Mixins for the PIXI.Container class.
+ * @class Container
+ * @memberof PIXI
+ */
+var p = PIXI.Container.prototype;
+
+/**
+ * Shortcut for `addChild`.
+ * @method PIXI.Container#ac
+ * @param {*} [child*] N-number of children
+ * @return {PIXI.DisplayObject} Instance of first child added
+ */
+p.ac = p.addChild;
+
+/**
+ * Extend a container
+ * @method PIXI.Container.extend
+ * @static
+ * @param {PIXI.Container} child The child function
+ * @return {PIXI.Container} THe child
+ */
+/**
+ * Extend a container (shortcut for `extend`)
+ * @method PIXI.Container.e
+ * @static
+ * @param {PIXI.Container} child The child function
+ * @return {PIXI.Container} THe child
+ */
+PIXI.Container.extend = PIXI.Container.e = function (child) {
+  child.prototype = Object.create(p);
+  child.prototype.__parent = p;
+  child.prototype.constructor = child;
+  return child;
+};
+//# sourceMappingURL=Container.js.map

Skills/@be/be/node_modules/pixi-animate/lib/mixins/Container.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/mixins/Container.js"],"names":["p","PIXI","Container","prototype","ac","addChild","extend","e","child","Object","create","__parent","constructor"],"mappings":";;AAAA;;;;;AAKA,IAAMA,IAAIC,KAAKC,SAAL,CAAeC,SAAzB;;AAEA;;;;;;AAMAH,EAAEI,EAAF,GAAOJ,EAAEK,QAAT;;AAEA;;;;;;;AAOA;;;;;;;AAOAJ,KAAKC,SAAL,CAAeI,MAAf,GAAwBL,KAAKC,SAAL,CAAeK,CAAf,GAAmB,UAASC,KAAT,EAAgB;AACvDA,QAAML,SAAN,GAAkBM,OAAOC,MAAP,CAAcV,CAAd,CAAlB;AACAQ,QAAML,SAAN,CAAgBQ,QAAhB,GAA2BX,CAA3B;AACAQ,QAAML,SAAN,CAAgBS,WAAhB,GAA8BJ,KAA9B;AACA,SAAOA,KAAP;AACH,CALD","file":"Container.js","sourcesContent":["/**\n * Mixins for the PIXI.Container class.\n * @class Container\n * @memberof PIXI\n */\nconst p = PIXI.Container.prototype;\n\n/**\n * Shortcut for `addChild`.\n * @method PIXI.Container#ac\n * @param {*} [child*] N-number of children\n * @return {PIXI.DisplayObject} Instance of first child added\n */\np.ac = p.addChild;\n\n/**\n * Extend a container\n * @method PIXI.Container.extend\n * @static\n * @param {PIXI.Container} child The child function\n * @return {PIXI.Container} THe child\n */\n/**\n * Extend a container (shortcut for `extend`)\n * @method PIXI.Container.e\n * @static\n * @param {PIXI.Container} child The child function\n * @return {PIXI.Container} THe child\n */\nPIXI.Container.extend = PIXI.Container.e = function(child) {\n    child.prototype = Object.create(p);\n    child.prototype.__parent = p;\n    child.prototype.constructor = child;\n    return child;\n};"]}

Skills/@be/be/node_modules/pixi-animate/lib/mixins/DisplayObject.js

@@ -0,0 +1,196 @@
+"use strict";
+
+var _utils = require("../animate/utils");
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Mixins for the PIXI.DisplayObject class.
+ * @memberof PIXI
+ * @class DisplayObject
+ */
+var p = PIXI.DisplayObject.prototype;
+
+// Color Matrix filter
+var ColorMatrixFilter = void 0;
+if (PIXI.filters) {
+  ColorMatrixFilter = PIXI.filters.ColorMatrixFilter;
+}
+
+/**
+ * Function to see if this is renderable or not. Useful for setting masks.
+ * @method PIXI.DisplayObject#setRenderable
+ * @param  {Boolean} [renderable=false] Make renderable
+ * @return {PIXI.DisplayObject}
+ */
+/**
+ * Shortcut to `setRenderable`.
+ * @method PIXI.DisplayObject#re
+ * @param  {Boolean} [renderable=false] Make renderable
+ * @return {PIXI.DisplayObject}
+ */
+p.setRenderable = p.re = function (renderable) {
+  this.renderable = !!renderable;
+  return this;
+};
+
+/**
+ * Shortcut for `setTransform`.
+ * @method PIXI.DisplayObject#tr
+ * @param {Number} x The X position
+ * @param {Number} y The Y position
+ * @param {Number} scaleX The X Scale value
+ * @param {Number} scaleY The Y Scale value
+ * @param {Number} skewX The X skew value
+ * @param {Number} skewY The Y skew value
+ * @param {Number} pivotX The X pivot value
+ * @param {Number} pivotY The Y pivot value
+ * @return {PIXI.DisplayObject} Instance for chaining
+ */
+p.t = p.setTransform;
+
+/**
+ * Setter for mask to be able to chain.
+ * @method PIXI.DisplayObject#setMask
+ * @param {PIXI.Graphics} mask The mask shape to use
+ * @return {PIXI.DisplayObject} Instance for chaining
+ */
+/**
+ * Shortcut for `setMask`.
+ * @method PIXI.DisplayObject#ma
+ * @param {PIXI.Sprite|PIXI.Graphics} mask The mask shape to use
+ * @return {PIXI.DisplayObject} Instance for chaining
+ */
+p.setMask = p.ma = function (mask) {
+  // According to PIXI, only Graphics and Sprites can 
+  // be used as mask, let's ignore everything else, like other
+  // movieclips and displayobjects/containers
+  if (mask) {
+    if (!(mask instanceof PIXI.Graphics) && !(mask instanceof PIXI.Sprite)) {
+      if (typeof console !== "undefined" && console.warn) {
+        console.warn("Warning: Masks can only be PIXI.Graphics or PIXI.Sprite objects.");
+      }
+      return this;
+    }
+  }
+  this.mask = mask;
+  return this;
+};
+
+/**
+ * Setter for the alpha
+ * @method PIXI.DisplayObject#setAlpha
+ * @param {Number} alpha The alpha amount to use, from 0 to 1
+ * @return {PIXI.DisplayObject} Instance for chaining
+ */
+/**
+ * Shortcut for `setAlpha`.
+ * @method PIXI.DisplayObject#a
+ * @param {Number} alpha The alpha amount to use, from 0 to 1
+ * @return {PIXI.DisplayObject} Instance for chaining
+ */
+p.setAlpha = p.a = function (alpha) {
+  this.alpha = alpha;
+  return this;
+};
+
+/**
+ * Set the tint values by color.
+ * @method PIXI.DisplayObject#setTint
+ * @param {int} tint The color value to tint
+ * @return {PIXI.DisplayObject} Object for chaining
+ */
+/**
+ * Shortcut to `setTint`.
+ * @method PIXI.DisplayObject#tn
+ * @param {Number|String} tint The red percentage value
+ * @return {PIXI.DisplayObject} Object for chaining
+ */
+p.setTint = p.i = function (tint) {
+  if (typeof tint === "string") {
+    tint = _utils2.default.hexToUint(tint);
+  }
+  // this.tint = tint
+  // return this;
+  // TODO: Replace with DisplayObject.tint setter
+  // once the functionality is added to Pixi.js, for
+  // now we'll use the slower ColorMatrixFilter to handle
+  // the color transformation
+  var r = tint >> 16 & 0xFF;
+  var g = tint >> 8 & 0xFF;
+  var b = tint & 0xFF;
+  return this.c(r / 255, 0, g / 255, 0, b / 255, 0);
+};
+
+/**
+ * Set additive and multiply color, tinting
+ * @method PIXI.DisplayObject#setColorTransform
+ * @param {Number} r The multiply red value
+ * @param {Number} rA The additive red value
+ * @param {Number} g The multiply green value
+ * @param {Number} gA The additive green value
+ * @param {Number} b The multiply blue value
+ * @param {Number} bA The additive blue value
+ * @return {PIXI.DisplayObject} Object for chaining
+ */
+/**
+ * Shortcut to `setColor`.
+ * @method PIXI.DisplayObject#c
+ * @param {Number} r The multiply red value
+ * @param {Number} rA The additive red value
+ * @param {Number} g The multiply green value
+ * @param {Number} gA The additive green value
+ * @param {Number} b The multiply blue value
+ * @param {Number} bA The additive blue value
+ * @return {PIXI.DisplayObject} Object for chaining
+ */
+p.setColorTransform = p.c = function (r, rA, g, gA, b, bA) {
+  var filter = this.colorTransformFilter;
+  filter.matrix[0] = r;
+  filter.matrix[4] = rA;
+  filter.matrix[6] = g;
+  filter.matrix[9] = gA;
+  filter.matrix[12] = b;
+  filter.matrix[14] = bA;
+  this.filters = [filter];
+  return this;
+};
+
+/**
+ * The current default color transforming filters
+ * @name {PIXI.filters.ColorMatrixFilter} PIXI.DisplayObject#colorTransformFilter
+ */
+if (!p.hasOwnProperty('colorTransformFilter')) {
+  Object.defineProperty(p, 'colorTransformFilter', {
+    set: function set(filter) {
+      this._colorTransformFilter = filter;
+    },
+    get: function get() {
+      return this._colorTransformFilter || new ColorMatrixFilter();
+    }
+  });
+}
+
+/**
+ * Extend a container
+ * @method PIXI.DisplayObject.extend
+ * @static
+ * @param {PIXI.DisplayObject} child The child function
+ * @return {PIXI.DisplayObject} THe child
+ */
+/**
+ * Extend a container (shortcut for `extend`)
+ * @method PIXI.DisplayObject.e
+ * @static
+ * @param {PIXI.DisplayObject} child The child function
+ * @return {PIXI.DisplayObject} THe child
+ */
+PIXI.DisplayObject.extend = PIXI.DisplayObject.e = function (child) {
+  child.prototype = Object.create(p);
+  child.prototype.__parent = p;
+  child.prototype.constructor = child;
+  return child;
+};
+//# sourceMappingURL=DisplayObject.js.map

Skills/@be/be/node_modules/pixi-animate/lib/mixins/Graphics.js

@@ -0,0 +1,302 @@
+"use strict";
+
+/**
+ * Mixins for the PIXI.Graphics class.
+ * @memberof PIXI
+ * @class Graphics
+ */
+var p = PIXI.Graphics.prototype;
+
+/**
+ * Shortcut for `drawCommands`.
+ * @method PIXI.Graphics#d
+ * @param  {Array} commands The commands and parameters to draw
+ * @return {PIXI.Graphics}
+ */
+/**
+ * Execute a series of commands, this is the name of the short function
+ * followed by the parameters, e.g., `["f", "#ff0000", "r", 0, 0, 100, 200]`
+ * @method PIXI.Graphics#drawCommands
+ * @param  {Array} commands The commands and parameters to draw
+ * @return {PIXI.Graphics}
+ */
+p.drawCommands = p.d = function (commands) {
+  var currentCommand,
+      params = [],
+      i = 0;
+
+  while (i <= commands.length) {
+    var item = commands[i++];
+    if (item === undefined || this[item]) {
+      if (currentCommand) {
+        this[currentCommand].apply(this, params);
+        params.length = 0;
+      }
+      currentCommand = item;
+    } else {
+      params.push(item);
+    }
+  }
+  return this;
+};
+
+/**
+ * Closes the current path, effectively drawing a line from the current drawing point to the first drawing point specified
+ * since the fill or stroke was last set.
+ * @method PIXI.Graphics#c
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.c = p.closePath;
+
+/**
+ * Alias for `addHole`
+ * @method PIXI.Graphics#h
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.h = p.addHole;
+
+/**
+ * Shortcut to `moveTo`.
+ * @method PIXI.Graphics#m
+ * @param {Number} x The x coordinate the drawing point should move to.
+ * @param {Number} y The y coordinate the drawing point should move to.
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls).
+ **/
+p.m = p.moveTo;
+
+/**
+ * Shortcut to `lineTo`.
+ * @method PIXI.Graphics#l
+ * @param {Number} x The x coordinate the drawing point should draw to.
+ * @param {Number} y The y coordinate the drawing point should draw to.
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.l = p.lineTo;
+
+/**
+ * Draws a quadratic curve from the current drawing point to (x, y) using the control point (cpx, cpy). For detailed
+ * information, read the <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#dom-context-2d-quadraticcurveto">
+ * whatwg spec</a>. A tiny API method "qt" also exists.
+ * @method PIXI.Graphics#q
+ * @param {Number} cpx
+ * @param {Number} cpy
+ * @param {Number} x
+ * @param {Number} y
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.q = p.quadraticCurveTo;
+
+/**
+ * Shortcut to `bezierCurveTo`.
+ * @method PIXI.Graphics#b
+ * @param {Number} cp1x
+ * @param {Number} cp1y
+ * @param {Number} cp2x
+ * @param {Number} cp2y
+ * @param {Number} x
+ * @param {Number} y
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.b = p.bezierCurveTo;
+
+/**
+ * Shortcut to `beginFill`.
+ * @method PIXI.Graphics#f
+ * @param {Uint} color The hex color value (e.g. 0xFFFFFF)
+ * null will result in no fill.
+ * @param {Number} [alpha=1] The alpha value of fill
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.f = p.beginFill;
+
+/**
+ * Shortcut to `lineStyle`.
+ * @method PIXI.Graphics#s
+ * @param {String} color A CSS compatible color value (ex. "#FF0000", "red", or "rgba(255,0,0,0.5)"). Setting to
+ * null will result in no stroke.
+ * @param {Number} [thickness=1] The thickness of the stroke
+ * @param {Number} [alpha=1] The alpha value from 0 (invisibile) to 1 (visible)
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.s = p.lineStyle;
+
+/**
+ * Shortcut to `drawRect`.
+ * @method PIXI.Graphics#dr
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} w Width of the rectangle
+ * @param {Number} h Height of the rectangle
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+/**
+ * Shortcut to `drawRect`.
+ * @method PIXI.Graphics#r
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} w Width of the rectangle
+ * @param {Number} h Height of the rectangle
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.dr = p.drawRect;
+
+/**
+ * Shortcut to `drawRoundedRect`.
+ * @method PIXI.Graphics#rr
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} w Width of the rectangle
+ * @param {Number} h Height of the rectangle
+ * @param {Number} radius The corner radius
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.rr = p.drawRoundedRect;
+
+/**
+ * Shortcut to `drawRoundedRect`.
+ * @method PIXI.Graphics#rc
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} w Width of the rectangle
+ * @param {Number} h Height of the rectangle
+ * @param {Number} radiusTL The top left corner radius
+ * @param {Number} radiusTR The top right corner radius
+ * @param {Number} radiusBR The bottom right corner radius
+ * @param {Number} radiusBL The bottom left corner radius
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.rc = p.drawRoundedRect;
+
+/**
+ * Shortcut to `drawCircle`.
+ * @method PIXI.Graphics#dc
+ * @param {Number} x x coordinate center point of circle.
+ * @param {Number} y y coordinate center point of circle.
+ * @param {Number} radius Radius of circle.
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.dc = p.drawCircle;
+
+/**
+ * Shortcut to `arc`.
+ * @method PIXI.Graphics#ac
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} radius
+ * @param {Number} startAngle Measured in radians.
+ * @param {Number} endAngle Measured in radians.
+ * @param {Boolean} anticlockwise
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.ar = p.arc;
+
+/**
+ * Shortcut to `arcTo`.
+ * @method PIXI.Graphics#at
+ * @param {Number} x1
+ * @param {Number} y1
+ * @param {Number} x2
+ * @param {Number} y2
+ * @param {Number} radius
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.at = p.arcTo;
+
+/**
+ * Shortcut to `drawEllipse`.
+ * @method  PIXI.Graphics#de
+ * @param  {Number} x      [description]
+ * @param  {Number} y      [description]
+ * @param  {Number} width  [description]
+ * @param  {Number} height [description]
+ */
+p.de = p.drawEllipse;
+
+/**
+ * Placeholder method for a linear fill. Pixi does not support linear fills,
+ * so we just pick the first color in colorArray
+ * @method PIXI.Graphics#lf
+ * @param {Array} colorArray An array of CSS compatible color values @see `f`
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.lf = function (colorArray) {
+  // @if DEBUG
+  console.warn("Linear gradient fills are not supported");
+  // @endif
+  return this.f(colorArray[0]);
+};
+
+/**
+ * Placeholder method for a radial fill. Pixi does not support radial fills,
+ * so we just pick the first color in colorArray
+ * @method PIXI.Graphics#rf
+ * @param {Array} colorArray An array of CSS compatible color values @see `f`
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.rf = function (colorArray) {
+  // @if DEBUG
+  console.warn("Radial gradient fills are not supported");
+  // @endif
+  return this.f(colorArray[0]);
+};
+
+/**
+ * Placeholder method for a `beginBitmapFill`. Pixi does not support bitmap fills.
+ * @method PIXI.Graphics#bf
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.bf = function () {
+  // @if DEBUG
+  console.warn("Bitmap fills are not supported");
+  // @endif
+  return this.f(0x0);
+};
+
+/**
+ * Placeholder method for a `setStrokeDash`. Pixi does not support dashed strokes.
+ * @method PIXI.Graphics#sd
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.sd = function () {
+  // @if DEBUG
+  console.warn("Dashed strokes are not supported");
+  // @endif
+  return this;
+};
+
+/**
+ * Placeholder method for a `beginBitmapStroke`. Pixi does not support bitmap strokes.
+ * @method PIXI.Graphics#bs
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.bs = function () {
+  // @if DEBUG
+  console.warn("Bitmap strokes are not supported");
+  // @endif
+  return this;
+};
+
+/**
+ * Placeholder method for a `beginLinearGradientStroke`. Pixi does not support gradient strokes.
+ * @method PIXI.Graphics#ls
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.ls = function () {
+  // @if DEBUG
+  console.warn("Linear gradient strokes are not supported");
+  // @endif
+  return this;
+};
+
+/**
+ * Placeholder method for a `beginRadialGradientStroke`. Pixi does not support gradient strokes.
+ * @method PIXI.Graphics#rs
+ * @return {PIXI.Graphics} The Graphics instance the method is called on (useful for chaining calls.)
+ **/
+p.rs = function () {
+  // @if DEBUG
+  console.warn("Radial gradient strokes are not supported");
+  // @endif
+  return this;
+};
+//# sourceMappingURL=Graphics.js.map

Skills/@be/be/node_modules/pixi-animate/lib/mixins/Sprite.js

@@ -0,0 +1,30 @@
+"use strict";
+
+/**
+ * Mixins for the PIXI.Sprite class.
+ * @memberof PIXI
+ * @class Sprite
+ */
+var p = PIXI.Sprite.prototype;
+
+/**
+ * Extend a container
+ * @method PIXI.Sprite.extend
+ * @static
+ * @param {PIXI.Sprite} child The child function
+ * @return {PIXI.Sprite} THe child
+ */
+/**
+ * Extend a container (shortcut for `extend`)
+ * @method PIXI.Sprite.e
+ * @static
+ * @param {PIXI.Sprite} child The child function
+ * @return {PIXI.Sprite} THe child
+ */
+PIXI.Sprite.extend = PIXI.Sprite.e = function (child) {
+  child.prototype = Object.create(p);
+  child.prototype.__parent = p;
+  child.prototype.constructor = child;
+  return child;
+};
+//# sourceMappingURL=Sprite.js.map

Skills/@be/be/node_modules/pixi-animate/lib/mixins/Sprite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/mixins/Sprite.js"],"names":["p","PIXI","Sprite","prototype","extend","e","child","Object","create","__parent","constructor"],"mappings":";;AAAA;;;;;AAKA,IAAMA,IAAIC,KAAKC,MAAL,CAAYC,SAAtB;;AAEA;;;;;;;AAOA;;;;;;;AAOAF,KAAKC,MAAL,CAAYE,MAAZ,GAAqBH,KAAKC,MAAL,CAAYG,CAAZ,GAAgB,UAASC,KAAT,EAAgB;AACjDA,QAAMH,SAAN,GAAkBI,OAAOC,MAAP,CAAcR,CAAd,CAAlB;AACAM,QAAMH,SAAN,CAAgBM,QAAhB,GAA2BT,CAA3B;AACAM,QAAMH,SAAN,CAAgBO,WAAhB,GAA8BJ,KAA9B;AACA,SAAOA,KAAP;AACH,CALD","file":"Sprite.js","sourcesContent":["/**\n * Mixins for the PIXI.Sprite class.\n * @memberof PIXI\n * @class Sprite\n */\nconst p = PIXI.Sprite.prototype;\n\n/**\n * Extend a container\n * @method PIXI.Sprite.extend\n * @static\n * @param {PIXI.Sprite} child The child function\n * @return {PIXI.Sprite} THe child\n */\n/**\n * Extend a container (shortcut for `extend`)\n * @method PIXI.Sprite.e\n * @static\n * @param {PIXI.Sprite} child The child function\n * @return {PIXI.Sprite} THe child\n */\nPIXI.Sprite.extend = PIXI.Sprite.e = function(child) {\n    child.prototype = Object.create(p);\n    child.prototype.__parent = p;\n    child.prototype.constructor = child;\n    return child;\n};"]}

Skills/@be/be/node_modules/pixi-animate/lib/mixins/Text.js

@@ -0,0 +1,125 @@
+"use strict";
+
+/**
+ * Mixins for the PIXI.Text class.
+ * @memberof PIXI
+ * @class Text
+ */
+var p = PIXI.Text.prototype;
+
+// Possible align values
+var ALIGN_VALUES = ["center", "right"];
+
+/**
+ * Setter for the alignment, also sets the anchor point
+ * to make sure the positioning is correct.
+ * @method PIXI.Text#setAlign
+ * @param {String} align Either, center, right, left
+ * @return {PIXI.Text} For chaining
+ */
+/**
+ * Shortcut for `setAlign`.
+ * @method PIXI.Text#g
+ * @param {String|int} align Either, center (0), right (1), left (-1)
+ * @return {PIXI.Text} For chaining
+ */
+p.setAlign = p.g = function (align) {
+    if (typeof align == "string") {
+        align = ALIGN_VALUES.indexOf(align);
+    }
+    this.style.align = ALIGN_VALUES[align] || "left";
+    this.anchor.x = (align + 1) / 2;
+    return this;
+};
+
+// Map of short names to long names
+var STYLE_PROPS = {
+    o: 'font', // TODO: deprecate in Pixi v4
+    z: 'fontSize',
+    f: 'fontFamily',
+    y: 'fontStyle',
+    g: 'fontWeight',
+    i: 'fill',
+    a: 'align',
+    s: 'stroke',
+    t: 'strokeThickness',
+    w: 'wordWrap',
+    d: 'wordWrapWidth',
+    l: 'lineHeight',
+    h: 'dropShadow',
+    c: 'dropShadowColor',
+    n: 'dropShadowAngle',
+    b: 'dropShadowBlur',
+    p: 'padding',
+    x: 'textBaseline',
+    j: 'lineJoin',
+    m: 'miterLimit',
+    e: 'letterSpacing'
+};
+
+/**
+ * Set the style, a chainable version of style setter
+ * @method PIXI.Text#setStyle
+ * @param {Object} style
+ * @return {PIXI.Text} instance of text field
+ */
+/**
+ * Shortcut for `setStyle`.
+ * @method PIXI.Text#ss
+ * @param {Object} style
+ * @return {PIXI.Text} instance of text field
+ */
+p.setStyle = p.ss = function (style) {
+    // Replace short STYLE_PROPS with long names
+    for (var k in STYLE_PROPS) {
+        if (style[k] !== undefined) {
+            style[STYLE_PROPS[k]] = style[k];
+            delete style[k];
+        }
+    }
+    this.style = style;
+    return this;
+};
+
+/**
+ * Initial setting of the drop shadow.
+ * @method PIXI.Text#setShadow
+ * @param {String} [color="#000000"] The color to set
+ * @param {Number} [angle=Math.PI/4] The angle of offset, in radians
+ * @param {Number} [distance=5] The offset distance
+ * @return {PIXI.Text} For chaining
+ */
+/**
+ * Shortcut for `setShadow`.
+ * @method PIXI.Text#sh
+ * @param {String} [color="#000000"] The color to set
+ * @param {Number} [angle=Math.PI/4] The angle of offset, in radians
+ * @param {Number} [distance=5] The offset distance
+ * @return {PIXI.Text} For chaining
+ */
+p.setShadow = p.sh = function (color, angle, distance) {
+    var style = this.style;
+    style.dropShadow = true;
+
+    // Convert color to hex string
+    if (color !== undefined) {
+        color = "#" + color.toString(16);
+    }
+    style.dropShadowColor = isUndefinedOr(color, style.dropShadowColor);
+    style.dropShadowAngle = isUndefinedOr(angle, style.dropShadowAngle);
+    style.dropShadowDistance = isUndefinedOr(distance, style.dropShadowDistance);
+    return this;
+};
+
+/**
+ * Check if a value is undefined, fallback to default value
+ * @method isUndefinedOr
+ * @private
+ * @param {*} value The value to check
+ * @param {*} defaultValue The default value if value is undefined
+ * @return {*} The either the value or the default value
+ */
+var isUndefinedOr = function isUndefinedOr(value, defaultValue) {
+    return value === undefined ? defaultValue : value;
+};
+//# sourceMappingURL=Text.js.map

Skills/@be/be/node_modules/pixi-animate/lib/mixins/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+exports.__esModule = true;
+
+var _Container = require('./Container');
+
+var _Container2 = _interopRequireDefault(_Container);
+
+var _DisplayObject = require('./DisplayObject');
+
+var _DisplayObject2 = _interopRequireDefault(_DisplayObject);
+
+var _Sprite = require('./Sprite');
+
+var _Sprite2 = _interopRequireDefault(_Sprite);
+
+var _Graphics = require('./Graphics');
+
+var _Graphics2 = _interopRequireDefault(_Graphics);
+
+var _Text = require('./Text');
+
+var _Text2 = _interopRequireDefault(_Text);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @namespace PIXI
+ */
+exports.default = {
+    Container: _Container2.default,
+    DisplayObject: _DisplayObject2.default,
+    Sprite: _Sprite2.default,
+    Graphics: _Graphics2.default,
+    Text: _Text2.default
+};
+//# sourceMappingURL=index.js.map

Skills/@be/be/node_modules/pixi-animate/lib/mixins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/mixins/index.js"],"names":["Container","DisplayObject","Sprite","Graphics","Text"],"mappings":";;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA;;;kBAGe;AACXA,kCADW;AAEXC,0CAFW;AAGXC,4BAHW;AAIXC,gCAJW;AAKXC;AALW,C","file":"index.js","sourcesContent":["import Container from './Container';\nimport DisplayObject from './DisplayObject';\nimport Sprite from './Sprite';\nimport Graphics from './Graphics';\nimport Text from './Text';\n\n/**\n * @namespace PIXI\n */\nexport default {\n    Container,\n    DisplayObject,\n    Sprite,\n    Graphics,\n    Text\n};"]}