HEX
Server: Apache
System: Linux pdx1-shared-a1-38 6.6.104-grsec-jammy+ #3 SMP Tue Sep 16 00:28:11 UTC 2025 x86_64
User: mmickelson (3396398)
PHP: 8.1.31
Disabled: NONE
Upload Files
File: //usr/share/rubygems-integration/all/gems/actionview-6.1.4.1/lib/assets/compiled/rails-ujs.js
/*
Unobtrusive JavaScript
https://github.com/rails/rails/blob/main/actionview/app/assets/javascripts
Released under the MIT license
 */

;
(function() {
  this.Rails = {
    linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',
    buttonClickSelector: {
      selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',
      exclude: 'form button'
    },
    inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',
    formSubmitSelector: 'form:not([data-turbo=true])',
    formInputClickSelector: 'form:not([data-turbo=true]) input[type=submit], form:not([data-turbo=true]) input[type=image], form:not([data-turbo=true]) button[type=submit], form:not([data-turbo=true]) button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',
    formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',
    formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',
    fileInputSelector: 'input[name][type=file]:not([disabled])',
    linkDisableSelector: 'a[data-disable-with], a[data-disable]',
    buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'
  };

}).call(this);
(function() {
  var nonce;

  nonce = null;

  Rails.loadCSPNonce = function() {
    var ref;
    return nonce = (ref = document.querySelector("meta[name=csp-nonce]")) != null ? ref.content : void 0;
  };

  Rails.cspNonce = function() {
    return nonce != null ? nonce : Rails.loadCSPNonce();
  };

}).call(this);
(function() {
  var expando, m;

  m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;

  Rails.matches = function(element, selector) {
    if (selector.exclude != null) {
      return m.call(element, selector.selector) && !m.call(element, selector.exclude);
    } else {
      return m.call(element, selector);
    }
  };

  expando = '_ujsData';

  Rails.getData = function(element, key) {
    var ref;
    return (ref = element[expando]) != null ? ref[key] : void 0;
  };

  Rails.setData = function(element, key, value) {
    if (element[expando] == null) {
      element[expando] = {};
    }
    return element[expando][key] = value;
  };

  Rails.$ = function(selector) {
    return Array.prototype.slice.call(document.querySelectorAll(selector));
  };

}).call(this);
(function() {
  var $, csrfParam, csrfToken;

  $ = Rails.$;

  csrfToken = Rails.csrfToken = function() {
    var meta;
    meta = document.querySelector('meta[name=csrf-token]');
    return meta && meta.content;
  };

  csrfParam = Rails.csrfParam = function() {
    var meta;
    meta = document.querySelector('meta[name=csrf-param]');
    return meta && meta.content;
  };

  Rails.CSRFProtection = function(xhr) {
    var token;
    token = csrfToken();
    if (token != null) {
      return xhr.setRequestHeader('X-CSRF-Token', token);
    }
  };

  Rails.refreshCSRFTokens = function() {
    var param, token;
    token = csrfToken();
    param = csrfParam();
    if ((token != null) && (param != null)) {
      return $('form input[name="' + param + '"]').forEach(function(input) {
        return input.value = token;
      });
    }
  };

}).call(this);
(function() {
  var CustomEvent, fire, matches, preventDefault;

  matches = Rails.matches;

  CustomEvent = window.CustomEvent;

  if (typeof CustomEvent !== 'function') {
    CustomEvent = function(event, params) {
      var evt;
      evt = document.createEvent('CustomEvent');
      evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
      return evt;
    };
    CustomEvent.prototype = window.Event.prototype;
    preventDefault = CustomEvent.prototype.preventDefault;
    CustomEvent.prototype.preventDefault = function() {
      var result;
      result = preventDefault.call(this);
      if (this.cancelable && !this.defaultPrevented) {
        Object.defineProperty(this, 'defaultPrevented', {
          get: function() {
            return true;
          }
        });
      }
      return result;
    };
  }

  fire = Rails.fire = function(obj, name, data) {
    var event;
    event = new CustomEvent(name, {
      bubbles: true,
      cancelable: true,
      detail: data
    });
    obj.dispatchEvent(event);
    return !event.defaultPrevented;
  };

  Rails.stopEverything = function(e) {
    fire(e.target, 'ujs:everythingStopped');
    e.preventDefault();
    e.stopPropagation();
    return e.stopImmediatePropagation();
  };

  Rails.delegate = function(element, selector, eventType, handler) {
    return element.addEventListener(eventType, function(e) {
      var target;
      target = e.target;
      while (!(!(target instanceof Element) || matches(target, selector))) {
        target = target.parentNode;
      }
      if (target instanceof Element && handler.call(target, e) === false) {
        e.preventDefault();
        return e.stopPropagation();
      }
    });
  };

}).call(this);
(function() {
  var AcceptHeaders, CSRFProtection, createXHR, cspNonce, fire, prepareOptions, processResponse;

  cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;

  AcceptHeaders = {
    '*': '*/*',
    text: 'text/plain',
    html: 'text/html',
    xml: 'application/xml, text/xml',
    json: 'application/json, text/javascript',
    script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
  };

  Rails.ajax = function(options) {
    var xhr;
    options = prepareOptions(options);
    xhr = createXHR(options, function() {
      var ref, response;
      response = processResponse((ref = xhr.response) != null ? ref : xhr.responseText, xhr.getResponseHeader('Content-Type'));
      if (Math.floor(xhr.status / 100) === 2) {
        if (typeof options.success === "function") {
          options.success(response, xhr.statusText, xhr);
        }
      } else {
        if (typeof options.error === "function") {
          options.error(response, xhr.statusText, xhr);
        }
      }
      return typeof options.complete === "function" ? options.complete(xhr, xhr.statusText) : void 0;
    });
    if ((options.beforeSend != null) && !options.beforeSend(xhr, options)) {
      return false;
    }
    if (xhr.readyState === XMLHttpRequest.OPENED) {
      return xhr.send(options.data);
    }
  };

  prepareOptions = function(options) {
    options.url = options.url || location.href;
    options.type = options.type.toUpperCase();
    if (options.type === 'GET' && options.data) {
      if (options.url.indexOf('?') < 0) {
        options.url += '?' + options.data;
      } else {
        options.url += '&' + options.data;
      }
    }
    if (AcceptHeaders[options.dataType] == null) {
      options.dataType = '*';
    }
    options.accept = AcceptHeaders[options.dataType];
    if (options.dataType !== '*') {
      options.accept += ', */*; q=0.01';
    }
    return options;
  };

  createXHR = function(options, done) {
    var xhr;
    xhr = new XMLHttpRequest();
    xhr.open(options.type, options.url, true);
    xhr.setRequestHeader('Accept', options.accept);
    if (typeof options.data === 'string') {
      xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
    }
    if (!options.crossDomain) {
      xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
      CSRFProtection(xhr);
    }
    xhr.withCredentials = !!options.withCredentials;
    xhr.onreadystatechange = function() {
      if (xhr.readyState === XMLHttpRequest.DONE) {
        return done(xhr);
      }
    };
    return xhr;
  };

  processResponse = function(response, type) {
    var parser, script;
    if (typeof response === 'string' && typeof type === 'string') {
      if (type.match(/\bjson\b/)) {
        try {
          response = JSON.parse(response);
        } catch (error) {}
      } else if (type.match(/\b(?:java|ecma)script\b/)) {
        script = document.createElement('script');
        script.setAttribute('nonce', cspNonce());
        script.text = response;
        document.head.appendChild(script).parentNode.removeChild(script);
      } else if (type.match(/\b(xml|html|svg)\b/)) {
        parser = new DOMParser();
        type = type.replace(/;.+/, '');
        try {
          response = parser.parseFromString(response, type);
        } catch (error) {}
      }
    }
    return response;
  };

  Rails.href = function(element) {
    return element.href;
  };

  Rails.isCrossDomain = function(url) {
    var e, originAnchor, urlAnchor;
    originAnchor = document.createElement('a');
    originAnchor.href = location.href;
    urlAnchor = document.createElement('a');
    try {
      urlAnchor.href = url;
      return !(((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host) || (originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host));
    } catch (error) {
      e = error;
      return true;
    }
  };

}).call(this);
(function() {
  var matches, toArray;

  matches = Rails.matches;

  toArray = function(e) {
    return Array.prototype.slice.call(e);
  };

  Rails.serializeElement = function(element, additionalParam) {
    var inputs, params;
    inputs = [element];
    if (matches(element, 'form')) {
      inputs = toArray(element.elements);
    }
    params = [];
    inputs.forEach(function(input) {
      if (!input.name || input.disabled) {
        return;
      }
      if (matches(input, 'fieldset[disabled] *')) {
        return;
      }
      if (matches(input, 'select')) {
        return toArray(input.options).forEach(function(option) {
          if (option.selected) {
            return params.push({
              name: input.name,
              value: option.value
            });
          }
        });
      } else if (input.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {
        return params.push({
          name: input.name,
          value: input.value
        });
      }
    });
    if (additionalParam) {
      params.push(additionalParam);
    }
    return params.map(function(param) {
      if (param.name != null) {
        return (encodeURIComponent(param.name)) + "=" + (encodeURIComponent(param.value));
      } else {
        return param;
      }
    }).join('&');
  };

  Rails.formElements = function(form, selector) {
    if (matches(form, 'form')) {
      return toArray(form.elements).filter(function(el) {
        return matches(el, selector);
      });
    } else {
      return toArray(form.querySelectorAll(selector));
    }
  };

}).call(this);
(function() {
  var allowAction, fire, stopEverything;

  fire = Rails.fire, stopEverything = Rails.stopEverything;

  Rails.handleConfirm = function(e) {
    if (!allowAction(this)) {
      return stopEverything(e);
    }
  };

  Rails.confirm = function(message, element) {
    return confirm(message);
  };

  allowAction = function(element) {
    var answer, callback, message;
    message = element.getAttribute('data-confirm');
    if (!message) {
      return true;
    }
    answer = false;
    if (fire(element, 'confirm')) {
      try {
        answer = Rails.confirm(message, element);
      } catch (error) {}
      callback = fire(element, 'confirm:complete', [answer]);
    }
    return answer && callback;
  };

}).call(this);
(function() {
  var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, isXhrRedirect, matches, setData, stopEverything;

  matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;

  Rails.handleDisabledElement = function(e) {
    var element;
    element = this;
    if (element.disabled) {
      return stopEverything(e);
    }
  };

  Rails.enableElement = function(e) {
    var element;
    if (e instanceof Event) {
      if (isXhrRedirect(e)) {
        return;
      }
      element = e.target;
    } else {
      element = e;
    }
    if (matches(element, Rails.linkDisableSelector)) {
      return enableLinkElement(element);
    } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {
      return enableFormElement(element);
    } else if (matches(element, Rails.formSubmitSelector)) {
      return enableFormElements(element);
    }
  };

  Rails.disableElement = function(e) {
    var element;
    element = e instanceof Event ? e.target : e;
    if (matches(element, Rails.linkDisableSelector)) {
      return disableLinkElement(element);
    } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {
      return disableFormElement(element);
    } else if (matches(element, Rails.formSubmitSelector)) {
      return disableFormElements(element);
    }
  };

  disableLinkElement = function(element) {
    var replacement;
    if (getData(element, 'ujs:disabled')) {
      return;
    }
    replacement = element.getAttribute('data-disable-with');
    if (replacement != null) {
      setData(element, 'ujs:enable-with', element.innerHTML);
      element.innerHTML = replacement;
    }
    element.addEventListener('click', stopEverything);
    return setData(element, 'ujs:disabled', true);
  };

  enableLinkElement = function(element) {
    var originalText;
    originalText = getData(element, 'ujs:enable-with');
    if (originalText != null) {
      element.innerHTML = originalText;
      setData(element, 'ujs:enable-with', null);
    }
    element.removeEventListener('click', stopEverything);
    return setData(element, 'ujs:disabled', null);
  };

  disableFormElements = function(form) {
    return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);
  };

  disableFormElement = function(element) {
    var replacement;
    if (getData(element, 'ujs:disabled')) {
      return;
    }
    replacement = element.getAttribute('data-disable-with');
    if (replacement != null) {
      if (matches(element, 'button')) {
        setData(element, 'ujs:enable-with', element.innerHTML);
        element.innerHTML = replacement;
      } else {
        setData(element, 'ujs:enable-with', element.value);
        element.value = replacement;
      }
    }
    element.disabled = true;
    return setData(element, 'ujs:disabled', true);
  };

  enableFormElements = function(form) {
    return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);
  };

  enableFormElement = function(element) {
    var originalText;
    originalText = getData(element, 'ujs:enable-with');
    if (originalText != null) {
      if (matches(element, 'button')) {
        element.innerHTML = originalText;
      } else {
        element.value = originalText;
      }
      setData(element, 'ujs:enable-with', null);
    }
    element.disabled = false;
    return setData(element, 'ujs:disabled', null);
  };

  isXhrRedirect = function(event) {
    var ref, xhr;
    xhr = (ref = event.detail) != null ? ref[0] : void 0;
    return (xhr != null ? xhr.getResponseHeader("X-Xhr-Redirect") : void 0) != null;
  };

}).call(this);
(function() {
  var stopEverything;

  stopEverything = Rails.stopEverything;

  Rails.handleMethod = function(e) {
    var csrfParam, csrfToken, form, formContent, href, link, method;
    link = this;
    method = link.getAttribute('data-method');
    if (!method) {
      return;
    }
    href = Rails.href(link);
    csrfToken = Rails.csrfToken();
    csrfParam = Rails.csrfParam();
    form = document.createElement('form');
    formContent = "<input name='_method' value='" + method + "' type='hidden' />";
    if ((csrfParam != null) && (csrfToken != null) && !Rails.isCrossDomain(href)) {
      formContent += "<input name='" + csrfParam + "' value='" + csrfToken + "' type='hidden' />";
    }
    formContent += '<input type="submit" />';
    form.method = 'post';
    form.action = href;
    form.target = link.target;
    form.innerHTML = formContent;
    form.style.display = 'none';
    document.body.appendChild(form);
    form.querySelector('[type="submit"]').click();
    return stopEverything(e);
  };

}).call(this);
(function() {
  var ajax, fire, getData, isCrossDomain, isRemote, matches, serializeElement, setData, stopEverything,
    slice = [].slice;

  matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, serializeElement = Rails.serializeElement;

  isRemote = function(element) {
    var value;
    value = element.getAttribute('data-remote');
    return (value != null) && value !== 'false';
  };

  Rails.handleRemote = function(e) {
    var button, data, dataType, element, method, url, withCredentials;
    element = this;
    if (!isRemote(element)) {
      return true;
    }
    if (!fire(element, 'ajax:before')) {
      fire(element, 'ajax:stopped');
      return false;
    }
    withCredentials = element.getAttribute('data-with-credentials');
    dataType = element.getAttribute('data-type') || 'script';
    if (matches(element, Rails.formSubmitSelector)) {
      button = getData(element, 'ujs:submit-button');
      method = getData(element, 'ujs:submit-button-formmethod') || element.method;
      url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;
      if (method.toUpperCase() === 'GET') {
        url = url.replace(/\?.*$/, '');
      }
      if (element.enctype === 'multipart/form-data') {
        data = new FormData(element);
        if (button != null) {
          data.append(button.name, button.value);
        }
      } else {
        data = serializeElement(element, button);
      }
      setData(element, 'ujs:submit-button', null);
      setData(element, 'ujs:submit-button-formmethod', null);
      setData(element, 'ujs:submit-button-formaction', null);
    } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {
      method = element.getAttribute('data-method');
      url = element.getAttribute('data-url');
      data = serializeElement(element, element.getAttribute('data-params'));
    } else {
      method = element.getAttribute('data-method');
      url = Rails.href(element);
      data = element.getAttribute('data-params');
    }
    ajax({
      type: method || 'GET',
      url: url,
      data: data,
      dataType: dataType,
      beforeSend: function(xhr, options) {
        if (fire(element, 'ajax:beforeSend', [xhr, options])) {
          return fire(element, 'ajax:send', [xhr]);
        } else {
          fire(element, 'ajax:stopped');
          return false;
        }
      },
      success: function() {
        var args;
        args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
        return fire(element, 'ajax:success', args);
      },
      error: function() {
        var args;
        args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
        return fire(element, 'ajax:error', args);
      },
      complete: function() {
        var args;
        args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
        return fire(element, 'ajax:complete', args);
      },
      crossDomain: isCrossDomain(url),
      withCredentials: (withCredentials != null) && withCredentials !== 'false'
    });
    return stopEverything(e);
  };

  Rails.formSubmitButtonClick = function(e) {
    var button, form;
    button = this;
    form = button.form;
    if (!form) {
      return;
    }
    if (button.name) {
      setData(form, 'ujs:submit-button', {
        name: button.name,
        value: button.value
      });
    }
    setData(form, 'ujs:formnovalidate-button', button.formNoValidate);
    setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));
    return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));
  };

  Rails.preventInsignificantClick = function(e) {
    var data, insignificantMetaClick, link, metaClick, method, nonPrimaryMouseClick;
    link = this;
    method = (link.getAttribute('data-method') || 'GET').toUpperCase();
    data = link.getAttribute('data-params');
    metaClick = e.metaKey || e.ctrlKey;
    insignificantMetaClick = metaClick && method === 'GET' && !data;
    nonPrimaryMouseClick = (e.button != null) && e.button !== 0;
    if (nonPrimaryMouseClick || insignificantMetaClick) {
      return e.stopImmediatePropagation();
    }
  };

}).call(this);
(function() {
  var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleDisabledElement, handleMethod, handleRemote, loadCSPNonce, preventInsignificantClick, refreshCSRFTokens;

  fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, loadCSPNonce = Rails.loadCSPNonce, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleDisabledElement = Rails.handleDisabledElement, handleConfirm = Rails.handleConfirm, preventInsignificantClick = Rails.preventInsignificantClick, handleRemote = Rails.handleRemote, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMethod = Rails.handleMethod;

  if ((typeof jQuery !== "undefined" && jQuery !== null) && (jQuery.ajax != null)) {
    if (jQuery.rails) {
      throw new Error('If you load both jquery_ujs and rails-ujs, use rails-ujs only.');
    }
    jQuery.rails = Rails;
    jQuery.ajaxPrefilter(function(options, originalOptions, xhr) {
      if (!options.crossDomain) {
        return CSRFProtection(xhr);
      }
    });
  }

  Rails.start = function() {
    if (window._rails_loaded) {
      throw new Error('rails-ujs has already been loaded!');
    }
    window.addEventListener('pageshow', function() {
      $(Rails.formEnableSelector).forEach(function(el) {
        if (getData(el, 'ujs:disabled')) {
          return enableElement(el);
        }
      });
      return $(Rails.linkDisableSelector).forEach(function(el) {
        if (getData(el, 'ujs:disabled')) {
          return enableElement(el);
        }
      });
    });
    delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);
    delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);
    delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);
    delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);
    delegate(document, Rails.linkClickSelector, 'click', preventInsignificantClick);
    delegate(document, Rails.linkClickSelector, 'click', handleDisabledElement);
    delegate(document, Rails.linkClickSelector, 'click', handleConfirm);
    delegate(document, Rails.linkClickSelector, 'click', disableElement);
    delegate(document, Rails.linkClickSelector, 'click', handleRemote);
    delegate(document, Rails.linkClickSelector, 'click', handleMethod);
    delegate(document, Rails.buttonClickSelector, 'click', preventInsignificantClick);
    delegate(document, Rails.buttonClickSelector, 'click', handleDisabledElement);
    delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);
    delegate(document, Rails.buttonClickSelector, 'click', disableElement);
    delegate(document, Rails.buttonClickSelector, 'click', handleRemote);
    delegate(document, Rails.inputChangeSelector, 'change', handleDisabledElement);
    delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);
    delegate(document, Rails.inputChangeSelector, 'change', handleRemote);
    delegate(document, Rails.formSubmitSelector, 'submit', handleDisabledElement);
    delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);
    delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);
    delegate(document, Rails.formSubmitSelector, 'submit', function(e) {
      return setTimeout((function() {
        return disableElement(e);
      }), 13);
    });
    delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);
    delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);
    delegate(document, Rails.formInputClickSelector, 'click', preventInsignificantClick);
    delegate(document, Rails.formInputClickSelector, 'click', handleDisabledElement);
    delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);
    delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);
    document.addEventListener('DOMContentLoaded', refreshCSRFTokens);
    document.addEventListener('DOMContentLoaded', loadCSPNonce);
    return window._rails_loaded = true;
  };

  if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {
    Rails.start();
  }

}).call(this);