Edit

[EDIT] FILE: block.zip

PK�����ӰZ[��p��������lineAppendor/_LineAppendor.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

// Generated by CoffeeScript 2.5.1
var _LineAppendor;

module.exports = _LineAppendor = /*#__PURE__*/function () {
  function _LineAppendor(_config) {
    _classCallCheck(this, _LineAppendor);

this._config = _config;
    this._lineNo = 0;
  }

_createClass(_LineAppendor, [{
    key: "render",
    value: function render(inherited, options) {
      this._lineNo++;
      return '<none>' + this._render(inherited, options) + '</none>';
    }
  }]);

return _LineAppendor;
}();PK�����ӰZ[JZ�������lineAppendor/Default.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

// Generated by CoffeeScript 2.5.1
var DefaultLineAppendor, tools;
tools = require('../../../tools');

module.exports = DefaultLineAppendor = /*#__PURE__*/function (_require) {
  _inherits(DefaultLineAppendor, _require);

var _super = _createSuper(DefaultLineAppendor);

function DefaultLineAppendor() {
    _classCallCheck(this, DefaultLineAppendor);

return _super.apply(this, arguments);
  }

_createClass(DefaultLineAppendor, [{
    key: "_render",
    value: function _render(inherited, options) {
      return inherited + tools.repeatString(" ", this._config.amount);
    }
  }]);

return DefaultLineAppendor;
}(require('./_LineAppendor'));PK�����ӰZ[i�͔S��S����blockAppendor/_BlockAppendor.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Generated by CoffeeScript 2.5.1
var _BlockAppendor;

module.exports = _BlockAppendor = /*#__PURE__*/function () {
  function _BlockAppendor(_config) {
    _classCallCheck(this, _BlockAppendor);

this._config = _config;
  }

_createClass(_BlockAppendor, [{
    key: "render",
    value: function render(options) {
      return this._render(options);
    }
  }]);

return _BlockAppendor;
}();PK�����ӰZ[�*�������blockAppendor/Default.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

// Generated by CoffeeScript 2.5.1
var DefaultBlockAppendor, tools;
tools = require('../../../tools');

module.exports = DefaultBlockAppendor = /*#__PURE__*/function (_require) {
  _inherits(DefaultBlockAppendor, _require);

var _super = _createSuper(DefaultBlockAppendor);

function DefaultBlockAppendor() {
    _classCallCheck(this, DefaultBlockAppendor);

return _super.apply(this, arguments);
  }

_createClass(DefaultBlockAppendor, [{
    key: "_render",
    value: function _render(options) {
      return tools.repeatString("\n", this._config.amount);
    }
  }]);

return DefaultBlockAppendor;
}(require('./_BlockAppendor'));PK�����ӰZ[��-��-����lineWrapper/_LineWrapper.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Generated by CoffeeScript 2.5.1
var _LineWrapper;

module.exports = _LineWrapper = /*#__PURE__*/function () {
  function _LineWrapper() {
    _classCallCheck(this, _LineWrapper);
  }

_createClass(_LineWrapper, [{
    key: "render",
    value: function render(str, options) {
      return this._render(str, options);
    }
  }]);

return _LineWrapper;
}();PK�����ӰZ[Fi�
���
����lineWrapper/Default.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

// Generated by CoffeeScript 2.5.1
var DefaultLineWrapper;

module.exports = DefaultLineWrapper = /*#__PURE__*/function (_require) {
  _inherits(DefaultLineWrapper, _require);

var _super = _createSuper(DefaultLineWrapper);

function DefaultLineWrapper() {
    _classCallCheck(this, DefaultLineWrapper);

return _super.apply(this, arguments);
  }

_createClass(DefaultLineWrapper, [{
    key: "_render",
    value: function _render() {}
  }]);

return DefaultLineWrapper;
}(require('./_LineWrapper'));PK�����ӰZ[+0�Y��Y��!��blockPrependor/_BlockPrependor.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Generated by CoffeeScript 2.5.1
var _BlockPrependor;

module.exports = _BlockPrependor = /*#__PURE__*/function () {
  function _BlockPrependor(_config) {
    _classCallCheck(this, _BlockPrependor);

this._config = _config;
  }

_createClass(_BlockPrependor, [{
    key: "render",
    value: function render(options) {
      return this._render(options);
    }
  }]);

return _BlockPrependor;
}();PK�����ӰZ[��;g������blockPrependor/Default.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

// Generated by CoffeeScript 2.5.1
var DefaultBlockPrependor, tools;
tools = require('../../../tools');

module.exports = DefaultBlockPrependor = /*#__PURE__*/function (_require) {
  _inherits(DefaultBlockPrependor, _require);

var _super = _createSuper(DefaultBlockPrependor);

function DefaultBlockPrependor() {
    _classCallCheck(this, DefaultBlockPrependor);

return _super.apply(this, arguments);
  }

_createClass(DefaultBlockPrependor, [{
    key: "_render",
    value: function _render(options) {
      return tools.repeatString("\n", this._config.amount);
    }
  }]);

return DefaultBlockPrependor;
}(require('./_BlockPrependor'));PK�����ӰZ[Ŧ���������linePrependor/_LinePrependor.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Generated by CoffeeScript 2.5.1
var _LinePrependor;

module.exports = _LinePrependor = /*#__PURE__*/function () {
  function _LinePrependor(_config) {
    _classCallCheck(this, _LinePrependor);

this._config = _config;
    this._lineNo = -1;
  }

_createClass(_LinePrependor, [{
    key: "render",
    value: function render(inherited, options) {
      this._lineNo++;
      return '<none>' + this._render(inherited, options) + '</none>';
    }
  }]);

return _LinePrependor;
}();PK�����ӰZ[%,pN��������linePrependor/Default.jsnu�ȯ����������"use strict";

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

// Generated by CoffeeScript 2.5.1
var DefaultLinePrependor, SpecialString, tools;
tools = require('../../../tools');
SpecialString = require('../../SpecialString');

module.exports = DefaultLinePrependor = function () {
  var self;

var DefaultLinePrependor = /*#__PURE__*/function (_require) {
    _inherits(DefaultLinePrependor, _require);

var _super = _createSuper(DefaultLinePrependor);

function DefaultLinePrependor() {
      _classCallCheck(this, DefaultLinePrependor);

return _super.apply(this, arguments);
    }

_createClass(DefaultLinePrependor, [{
      key: "_render",
      value: function _render(inherited, options) {
        var addToLeft, addToRight, alignment, bullet, char, charLen, diff, left, output, space, toWrite;

if (this._lineNo === 0 && (bullet = this._config.bullet)) {
          char = bullet.char;
          charLen = new SpecialString(char).length;
          alignment = bullet.alignment;
          space = this._config.amount;
          toWrite = char;
          addToLeft = '';
          addToRight = '';

if (space > charLen) {
            diff = space - charLen;

if (alignment === 'right') {
              addToLeft = self.pad(diff);
            } else if (alignment === 'left') {
              addToRight = self.pad(diff);
            } else if (alignment === 'center') {
              left = Math.round(diff / 2);
              addToLeft = self.pad(left);
              addToRight = self.pad(diff - left);
            } else {
              throw Error("Unknown alignment `".concat(alignment, "`"));
            }
          }

output = addToLeft + char + addToRight;
        } else {
          output = self.pad(this._config.amount);
        }

return inherited + output;
      }
    }], [{
      key: "pad",
      value: function pad(howMuch) {
        return tools.repeatString(" ", howMuch);
      }
    }]);

return DefaultLinePrependor;
  }(require('./_LinePrependor'));

;
  self = DefaultLinePrependor;
  return DefaultLinePrependor;
}.call(void 0);PK�������ӰZ[��p����������������������lineAppendor/_LineAppendor.jsnu�ȯ����������PK�������ӰZ[JZ��������������������lineAppendor/Default.jsnu�ȯ����������PK�������ӰZ[i�͔S��S��������������Y��blockAppendor/_BlockAppendor.jsnu�ȯ����������PK�������ӰZ[�*��������������������blockAppendor/Default.jsnu�ȯ����������PK�������ӰZ[��-��-��������������U&��lineWrapper/_LineWrapper.jsnu�ȯ����������PK�������ӰZ[Fi�
���
���������������*��lineWrapper/Default.jsnu�ȯ����������PK�������ӰZ[+0�Y��Y��!�������������8��blockPrependor/_BlockPrependor.jsnu�ȯ����������PK�������ӰZ[��;g����������������K=��blockPrependor/Default.jsnu�ȯ����������PK�������ӰZ[Ŧ��������������������K��linePrependor/_LinePrependor.jsnu�ȯ����������PK�������ӰZ[%,pN�������������������P��linePrependor/Default.jsnu�ȯ����������PK����
�
�����d����

CANCEL