webpackJsonp([1],{

/***/ 0:
/***/ function(module, exports, __webpack_require__) {

	__webpack_require__(40);

/***/ },

/***/ 40:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(2), __webpack_require__(41), __webpack_require__(42), __webpack_require__(43), __webpack_require__(44), __webpack_require__(50), __webpack_require__(3), __webpack_require__(6)], __WEBPACK_AMD_DEFINE_RESULT__ = function (exports, _jquery, _javascriptsAnswerDetailTableDraw, _javascriptsAnswerDetailCollapsibleDraw, _javascriptsAnswerDetailCollapsibleListen, _javascriptsAnswerDetailFeedbackLoad, _javascriptsCommonModulesCharCountLimiterLoad, _javascriptsCommonUtilsTemplatesLoader, _javascriptsConfigTemplates) {
	  'use strict';

	  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

	  var _$ = _interopRequireDefault(_jquery);

	  var _drawTable = _interopRequireDefault(_javascriptsAnswerDetailTableDraw);

	  var _drawCollapsible = _interopRequireDefault(_javascriptsAnswerDetailCollapsibleDraw);

	  var _listenCollapsible = _interopRequireDefault(_javascriptsAnswerDetailCollapsibleListen);

	  var _loadFeedback = _interopRequireDefault(_javascriptsAnswerDetailFeedbackLoad);

	  var _loadCharLimiter = _interopRequireDefault(_javascriptsCommonModulesCharCountLimiterLoad);

	  var _loader = _interopRequireDefault(_javascriptsCommonUtilsTemplatesLoader);

	  var _TEMPLATES = _interopRequireDefault(_javascriptsConfigTemplates);

	  var SELECTORS = {
	    ANSWER: '.js-answer'
	  };

	  // Delegated Modules
	  _loadCharLimiter['default']();
	  _listenCollapsible['default']();
	  _loadFeedback['default']();

	  function pageLoaded() {
	    _$['default'](SELECTORS.ANSWER).each(function () {
	      _drawCollapsible['default'](_$['default'](this));
	      _drawTable['default'](_$['default'](this));
	    });
	  }

	  _loader['default'](_TEMPLATES['default'].ANSWER_DETAIL, pageLoaded);
	}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },

/***/ 41:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var $ = __webpack_require__(2);

	  var DEFAULT_CONFIG = {

	    SELECTORS : {
	      TABLE : 'table'
	    },

	    CLASSES : {
	      TABLE_WRAPPER : 'table-wrapper'
	    }

	  };

	  module.exports = function draw_table($element, options) {

	    var CONFIG = $.extend({}, DEFAULT_CONFIG, (options || {}));

	    // STATIC ELEMENTS
	    var $table = $element.find(CONFIG.SELECTORS.TABLE);

	    $table.wrap('<div class="' + CONFIG.CLASSES.TABLE_WRAPPER + '"></div>');

	  };

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));


/***/ },

/***/ 42:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var $ = __webpack_require__(2);

	  var DEFAULT_CONFIG = {

	    SELECTORS : {
	      COLLAPSIBLE : '.collapsible',
	      HEADER      : 'div:first-child'
	    },

	    CLASSES : {
	      HEADER_WRAPPER : 'collapsible-header-wrapper',
	      HEADER         : 'collapsible-header',
	      CONTENT        : 'collapsible-content'
	    },

	    ATTRIBUTES : {
	      ID_PREFIX : 'collapsible-content-'
	    }

	  };

	  module.exports = function draw_collapsible($element, options) {

	    var CONFIG = $.extend({}, DEFAULT_CONFIG, (options || {}));

	    // HELPER FUNCTIONS
	    var formatHeader = function($element, index) {

	      var headerAttributes  = {
	            'class'         : CONFIG.CLASSES.HEADER_WRAPPER
	          },
	          buttonAttributes  = {
	            'aria-expanded' : 'false',
	            'aria-controls' : CONFIG.ATTRIBUTES.ID_PREFIX + index,
	            'class'         : CONFIG.CLASSES.HEADER
	          },
	          $newHeader        = $('<h3 />'),
	          $headerTrigger    = $('<button />'),
	          content           = $element.text();

	      return (
	        $newHeader
	          .attr(headerAttributes)
	          .append(
	            $headerTrigger
	              .attr(buttonAttributes)
	              .text(content)
	            )
	      );
	    };

	    var formatContent = function(content, index) {

	      var contentAttributes = {
	            'id'            : CONFIG.ATTRIBUTES.ID_PREFIX + index,
	            'class'         : CONFIG.CLASSES.CONTENT,
	            'aria-hidden'   : 'true'
	          },
	          $contentWrapper   = $('<div />');

	      return (
	        $contentWrapper
	          .attr(contentAttributes)
	          .html(content)
	      );
	    };

	    // STATIC ELEMENTS
	    var $collapsible = $element.find(CONFIG.SELECTORS.COLLAPSIBLE);

	    // update the markup around the collapsibles to make it easier to target content to hide/show
	    $collapsible.each(function(index) {

	      var $this               = $(this),
	          content             = $this.html(),
	          $collapsibleHeader  = $(content).filter(CONFIG.SELECTORS.HEADER),
	          $newHeader          = formatHeader($collapsibleHeader, index),
	          $collapsibleContent = formatContent(content, index),
	          $headerToRemove     = $collapsibleContent.find(CONFIG.SELECTORS.HEADER); // the content includes the header, so that needs to be plucked

	      $headerToRemove.remove(); // pluck the duplicate header

	      $this.empty(); // empty out the .collapsible element
	      $this.append($newHeader); // add the header back in
	      $this.append($collapsibleContent); // add the content (minus duplicat header) back in
	    });

	  };

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },

/***/ 43:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, module, __webpack_require__(2), __webpack_require__(5)], __WEBPACK_AMD_DEFINE_RESULT__ = function (exports, module, _jquery, _frampton) {
	  'use strict';

	  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

	  var _$ = _interopRequireDefault(_jquery);

	  var _frampton2 = _interopRequireDefault(_frampton);

	  var onSelector = _frampton2['default'].Events.onSelector;
	  var containsSelector = _frampton2['default'].Events.containsSelector;

	  var DEFAULT_CONFIG = {

	    SELECTORS: {
	      COLLAPSIBLE: '.collapsible',
	      HEADER_TRIGGER: '.collapsible-header',
	      CONTENT: '.collapsible-content'
	    },

	    CLASSES: {
	      EXPANDED: 'expanded'
	    }

	  };

	  module.exports = function (options) {

	    var CONFIG = _$['default'].extend({}, DEFAULT_CONFIG, options || {});

	    // STREAMS
	    var toggle = onSelector('click', CONFIG.SELECTORS.COLLAPSIBLE).filter(containsSelector(CONFIG.SELECTORS.HEADER_TRIGGER));

	    // make the collapsible headers clickable
	    toggle.next(function (evt) {
	      _$['default'](evt.target).attr('aria-expanded', function () {
	        return _$['default'](this).attr('aria-expanded') === "false" ? "true" : "false";
	      }).closest(CONFIG.SELECTORS.COLLAPSIBLE).toggleClass(CONFIG.CLASSES.EXPANDED).find(CONFIG.SELECTORS.CONTENT).attr('aria-hidden', function () {
	        return _$['default'](this).attr('aria-hidden') === "false" ? "true" : "false";
	      });
	    });
	  };
	}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },

/***/ 44:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var $                 = __webpack_require__(2),
	      i18n_cache        = __webpack_require__(13),
	      not               = __webpack_require__(5).Utils.not,
	      onSelector        = __webpack_require__(5).Events.onSelector,
	      describe          = __webpack_require__(5).Motion.describe,
	      ROUTES            = __webpack_require__(45),
	      CONFIG            = __webpack_require__(46),
	      toRating          = __webpack_require__(47).toRating,
	      toInitialState    = __webpack_require__(47).toInitialState,
	      isCloseButton     = __webpack_require__(47).isCloseButton,
	      isValidPayload    = __webpack_require__(47).isValidPayload,
	      toFeedbackPayload = __webpack_require__(47).toFeedbackPayload,
	      isClosed          = __webpack_require__(47).isClosed,
	      isRating          = __webpack_require__(47).isRating,
	      isUnhelpful       = __webpack_require__(47).isUnhelpful,
	      isSingleStep      = __webpack_require__(47).isSingleStep,
	      toRequestUrl      = __webpack_require__(48).toRequestUrl,
	      isMobile          = __webpack_require__(20).checkMobile;

	  function AnswerFeedback(options) {

	    // BASE EVENT STREAMS
	    var clicks  = onSelector('click', CONFIG.SELECTORS.HELPFULNESS);
	    var submits = onSelector('submit', CONFIG.SELECTORS.HELPFULNESS);

	    // TRANSFORMED STREAMS
	    var clickTargets = clicks
	      .map(toInitialState)
	      .filter(not(isClosed));

	    var ratingClicks = clickTargets
	      .filter(isRating);

	    var closeClicks = clickTargets
	      .filter(isCloseButton);

	    var ratings = ratingClicks
	      .map(toRating);

	    var showFeedback = ratings
	      .filter(not(isMobile))
	      .filter(not(isSingleStep))
	      .filter(isUnhelpful);

	    var feedbackPayload = submits
	      .preventDefault()
	      .map(toInitialState)
	      .filter(not(isClosed))
	      .map(toFeedbackPayload);

	    var validPayload = feedbackPayload
	      .filter(isValidPayload);

	    var invalidPayload = feedbackPayload
	      .filter(not(isValidPayload));

	    var closeFeedback = closeClicks
	      .merge(validPayload);

	    // SIDE EFFECTS
	    ratings.next(function(model) {

	      var $element = model.$root;
	      var $prompt = $element.find(CONFIG.SELECTORS.PROMPT);
	      var $ratings = $element.find(CONFIG.SELECTORS.RATING);
	      var $rateActions = $element.find(CONFIG.SELECTORS.RATING_CONTAINER);

	      $.post(toRequestUrl(ROUTES.RATE_API, model.id), {
	        rating: model.data
	      });

	      $prompt.text(CONFIG.RATING_SUBMIT_MESSAGE);
	      $element.addClass(CONFIG.CLASSES.RATING_SUBMITTED);

	      // Transfer focus back to the root since the buttons will be disappearing
	      // and disable the buttons so you can't tab back to them before they disappear
	      if (model.data !== 1) {
	        $element.trigger('focus');
	      }

	      $ratings.prop('disabled', true);

	      // display:none needs to be applied so that screen readers no longer see the buttons
	      // A delay was added to allow it to show the fade and shink button animations
	      $rateActions.attr('aria-hidden', 'true').delay(300).remove();

	    });

	    showFeedback.next(function(model) {

	      var $element = model.$root;
	      var $feedback = $element.find(CONFIG.SELECTORS.FEEDBACK);
	      var $feedbackForm = $feedback.find(CONFIG.SELECTORS.FEEDBACK_FORM);

	      $element.addClass(CONFIG.CLASSES.SHOW_FEEDBACK);

	      describe($feedback[0], CONFIG.CLASSES.REVEAL_FEEDBACK, {
	        height : CONFIG.FEEDBACK_HEIGHT_OFFSET + $feedbackForm.outerHeight(true)
	      }).run(function() {
	        $feedback.attr('aria-hidden', 'false');
	        $feedbackForm.trigger('focus');
	      });
	    });

	    invalidPayload.next(function(model) {

	      var $element = model.$root;
	      var $feedback = $element.find(CONFIG.SELECTORS.FEEDBACK);
	      var $feedbackForm = $feedback.find(CONFIG.SELECTORS.FEEDBACK_FORM);
	      var $warning = $element.find(CONFIG.SELECTORS.WARNING);
	      var $warningTarget = $element.find(CONFIG.SELECTORS.WARNING_TARGET);

	      $element.addClass(CONFIG.CLASSES.SHOW_WARNING);

	      $warning
	        .attr('aria-hidden', 'false')
	        .html("<span class='a11y-hidden'>" + i18n_cache.get('i18n_ask_field_error') + "</span>" + " " + i18n_cache.get('i18n_feedback_reason'));

	      $warningTarget.trigger('focus');

	      $feedback.height( $feedbackForm.outerHeight(true) );
	    });

	    validPayload.next(function(model) {
	      $.post(toRequestUrl(ROUTES.FEEDBACK_API, model.id), model.data);
	    });

	    closeFeedback.next(function(model) {

	      var $element = model.$root;
	      var $feedback = $element.find(CONFIG.SELECTORS.FEEDBACK);

	      $element[0].setAttribute('data-is-closed', 'true');
	      $feedback.removeClass(CONFIG.CLASSES.REVEAL_FEEDBACK);

	      describe($feedback[0], {
	        height : 0
	      }).run(function() {
	        // Transfer focus back to the root since feedback items (submit/cancel buttons) will be disappearing
	        $element.trigger('focus');
	        $feedback.attr('aria-hidden', 'true');
	        $element.removeClass(CONFIG.CLASSES.SHOW_FEEDBACK);
	        $feedback.remove();
	      });
	    });

	  }

	  module.exports = AnswerFeedback;

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));


/***/ },

/***/ 46:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var i18n_cache = __webpack_require__(13);

	  module.exports = {

	    SELECTORS : {
	      ANSWER           : '.js-answer',
	      HELPFULNESS      : '.js-helpfulness',
	      CLOSE_BUTTON     : '.js-close-button',
	      SUBMIT_BUTTON    : '.js-submit-button',
	      PROMPT           : '.js-prompt',
	      FEEDBACK         : '.js-feedback',
	      FEEDBACK_FORM    : '.js-feedback-form',
	      FEEDBACK_TEXT    : '.js-feedback-text',
	      RATING_CONTAINER : '.js-actions',
	      RATING           : '.js-action',
	      WARNING          : '.js-warning-message',
	      WARNING_TARGET   : '.js-warning-target'
	    },

	    CLASSES : {
	      RATING_SUBMITTED : 'rating-succeeded',
	      SHOW_FEEDBACK    : 'enter-feedback',
	      SHOW_WARNING     : 'feedback-missing',
	      REVEAL_FEEDBACK  : 'show-feedback',
	      SINGLE_STEP      : 'js-single-step'
	    },

	    // this value is needed for proper height animations
	    // it is equal to the margin-top value of the element
	    // @TODO: refactor the CSS so this isn't required
	    FEEDBACK_HEIGHT_OFFSET: 16,

	    TIMINGS : {
	      FEEDBACK_TRANSITION: 400
	    },

	    RATING_SUBMIT_MESSAGE: i18n_cache.get('i18n_feedback_header')
	  };

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));


/***/ },

/***/ 47:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var $        = __webpack_require__(2),
	      contains = __webpack_require__(5).Style.selectorContains,
	      update   = __webpack_require__(5).Object.update,
	      CONFIG   = __webpack_require__(46);

	  module.exports = {

	    toInitialState : function(evt) {

	      var $root = $(evt.target).parents(CONFIG.SELECTORS.HELPFULNESS);

	      return {
	        $root    : $root,
	        isClosed : ($root.data('is-closed') === 'true'),
	        target   : evt.target,
	        data     : null,
	        id       : $(evt.target).parents(CONFIG.SELECTORS.ANSWER).data('answer-id')
	      };
	    },

	    toFeedbackPayload : function(model) {
	      return update(model, 'data', {
	        reason : model.$root.find('input[name=reason]:checked').val(),
	        feedback : model.$root.find(CONFIG.SELECTORS.FEEDBACK_TEXT).val()
	      });
	    },

	    isClosed : function(model) {
	      return model.isClosed;
	    },

	    isRating : function(model) {
	      return contains(CONFIG.SELECTORS.RATING, model.target);
	    },

	    isCloseButton : function(model) {
	      return contains(CONFIG.SELECTORS.CLOSE_BUTTON, model.target);
	    },

	    toRating : function(model) {
	      return update(model, 'data', $(model.target).data('rating'));
	    },

	    isValidPayload : function(model) {
	      return (model.data && !!model.data.reason);
	    },

	    isUnhelpful : function(model) {
	      return (model && model.data && model.data === 1);
	    },

	    isSingleStep : function(model) {
	      return (model && $(model.target).hasClass(CONFIG.CLASSES.SINGLE_STEP));
	    }

	  };

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));


/***/ },

/***/ 50:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/**
	 * Textbox and textarea character counter.
	 * @author Martin Sanchez <msanchez@linkedin.com>
	 *
	 * Allows custom char count messages with variables %count / %max.
	 * Fires up callback functions when certain events occur.
	 * Displays counter message only after a configurable threshold
	 */
	!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var $          = __webpack_require__(2),
	      onSelector = __webpack_require__(5).Events.onSelector,
	      not        = __webpack_require__(5).Utils.not,
	      isEmpty    = __webpack_require__(5).Utils.isEmpty,
	      CONFIG     = __webpack_require__(51).CONFIG,
	      SELECTORS  = __webpack_require__(51).SELECTORS,
	      CLASSES    = __webpack_require__(51).CLASSES;

	  // HELPERS
	  var isBelowLimit = function(model) {
	    return (model.length < CONFIG.CHAR_LIMIT);
	  };

	  var isBelowThreshold = function(model) {
	    return (model.length < CONFIG.WARNING_THRESHOLD);
	  };

	  var renderText = function render_text(count) {
	    var rendered_text = "";

	    // If counter format was not defined, just return the counter
	    if (isEmpty(CONFIG.COUNTER_FORMAT)) {
	      return count + "/" + CONFIG.CHAR_LIMIT;
	    }

	    // Since we allow the use of two variables (%count and %max) to craft a message, we must
	    // call "replace" twice. Only two variables needed, so no need to over-engineer it.

	    // If maximun has not been exceeded, or if EXCEEDED_FORMAT has not been defined,
	    // then show message in COUNTER_FORMAT
	    if (count < CONFIG.CHAR_LIMIT  || isEmpty(CONFIG.MAX_REACHED_FORMAT)) {
	      rendered_text = CONFIG.COUNTER_FORMAT.replace(/%count/, count);
	    } else {  // If maximun has been exceeded, show message in EXCEEDED_FORMAT
	      rendered_text = CONFIG.MAX_REACHED_FORMAT.replace(/%count/, count);
	    }

	    return rendered_text.replace(/%max/, CONFIG.CHAR_LIMIT);
	  };

	  module.exports = function char_count_limiter() {

	    // MODEL
	    var toInitialModel = function(evt) {

	      var $parent = $(evt.target).closest(SELECTORS.CONTAINER);
	      var $textarea = $parent.find(SELECTORS.FEEDBACK_TEXT);
	      var $feedback = $parent.find(SELECTORS.LIMIT_FEEDBACK);
	      var $button = $parent.find(SELECTORS.SUBMIT_BUTTON);
	      var value = $textarea.val();

	      return {
	        textarea       : $textarea,
	        feedback       : $feedback,
	        button         : $button,
	        value          : value,
	        length         : value.length,
	        aboveLimit     : false,
	        aboveThreshold : false
	      };
	    };

	    // STREAMS

	    //+ inputStream :: EventStream DomEvent
	    var inputStream = onSelector('input', SELECTORS.FEEDBACK_TEXT);

	    //+ modelStream :: EventStream Object
	    var modelStream = inputStream.map(toInitialModel);

	    //+ belowLimit :: EventStream Object
	    var belowLimit = modelStream.filter(isBelowLimit);

	    //+ aboveLimit :: EventStream Object
	    var aboveLimit = modelStream.filter(not(isBelowLimit));

	    //+ belowThreshold :: EventStream Object
	    var belowThreshold = modelStream.filter(isBelowThreshold);

	    //+ aboveThreshold :: EventStream Object
	    var aboveThreshold = modelStream.filter(not(isBelowThreshold));

	    // SIDE EFFECTS
	    belowThreshold.next(function(model) {
	      if (model.textarea.hasClass(CLASSES.TEXTBOX_WARNING)) {
	        model.feedback.html('');
	        model.textarea.removeClass(CLASSES.TEXTBOX_WARNING);
	      }
	    });

	    aboveThreshold.next(function(model) {
	      model.feedback.html(renderText(model.length));
	      if (!model.textarea.hasClass(CLASSES.TEXTBOX_WARNING)) {
	        model.textarea.addClass(CLASSES.TEXTBOX_WARNING);
	      }
	    });

	    belowLimit.next(function(model) {
	      if (model.textarea.hasClass(CLASSES.TEXTBOX_ERROR)) {
	        model.button.prop('disabled', false);
	        model.textarea.removeClass(CLASSES.TEXTBOX_ERROR);
	      }
	    });

	    aboveLimit.next(function(model) {
	      if (!model.textarea.hasClass(CLASSES.TEXTBOX_ERROR)) {
	        model.button.prop('disabled', true);
	        model.textarea.addClass(CLASSES.TEXTBOX_ERROR);
	      }
	    });

	  };

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ },

/***/ 51:
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function(require, exports, module) {

	  'use strict';

	  var i18n_cache = __webpack_require__(13);

	  exports.CONFIG = {
	    CHAR_LIMIT         : 1000,
	    WARNING_THRESHOLD  : 800,
	    COUNTER_FORMAT     : i18n_cache.get('i18n_feedback_textbox_count_warning'),
	    MAX_REACHED_FORMAT : i18n_cache.get('i18n_feedback_textbox_count_error')
	  };

	  exports.SELECTORS = {
	    CONTAINER      : '.js-char-count-limiter',
	    FEEDBACK_TEXT  : '.js-limit-text',
	    LIMIT_FEEDBACK : '.js-limit-feedback',
	    SUBMIT_BUTTON  : '.js-submit-button'
	  };

	  exports.CLASSES = {
	    TEXTBOX_ERROR   : 'input-field-error',
	    TEXTBOX_WARNING : 'input-field-warning'
	  };

	}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

/***/ }

});