Response:
sloc    = require '../sloc'
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

stat = (data, options) ->

  if data.badFile
    return "#{align i18n.en.Error, col} :  #{i18n.en.BadFile}"

  str = for k in options.keys when (x = data.stats[k])?
    "#{align i18n.en[k], col} :  #{x}"

  str.join '\n'

module.exports = (data, options={}) ->

  if options.keys?.length is 1 and not options.reportDetails
    return data.summary[options.keys[0]]

  if not options.keys?
    options.keys = sloc.keys

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat {stats: data.summary}, options

  badFiles = data.files.filter (x) -> x.badFile

  result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.files.length - badFiles.length}"

  if bl = badFiles.length > 0
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{badFiles.length}"

  if options.details and data.files.length > 1
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for f in data.files
      "\n\n--- #{f.path}\n\n#{stat f, options}"

    result += d.join ''

  result += "\n\n------------------------------\n"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
sloc    = require '../sloc'
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

stat = (data, options) ->

  if data.badFile
    return "#{align i18n.en.Error, col} :  #{i18n.en.BadFile}"

  str = for k in options.keys when (x = data.stats[k])?
    "#{align i18n.en[k], col} :  #{x}"

  str.join '\n'

module.exports = (data, options={}) ->

  if options.keys?.length is 1 and not options.reportDetails
    return data.summary[options.keys[0]]

  if not options.keys?
    options.keys = sloc.keys

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat {stats: data.summary}, options

  badFiles = data.files.filter (x) -> x.badFile

  result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.files.length - badFiles.length}"

  if bl = badFiles.length > 0
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{badFiles.length}"

  if options.details and data.files.length > 1
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for f in data.files
      "\n\n--- #{f.path}\n\n#{stat f, options}"

    result += d.join ''

  result += "\n\n------------------------------\n"
```

Response:
var align, col, helpers, i18n, sloc, stat;

sloc = require('../sloc');

i18n = require('../i18n');

helpers = require('../helpers');

align = helpers.alignRight;

col = 20;

stat = function(data, options) {
  var k, str, x;
  if (data.badFile) {
    return `${align(i18n.en.Error, col)} :  ${i18n.en.BadFile}`;
  }
  str = (function() {
    var i, len, ref, results;
    ref = options.keys;
    results = [];
    for (i = 0, len = ref.length; i < len; i++) {
      k = ref[i];
      if ((x = data.stats[k]) != null) {
        results.push(`${align(i18n.en[k], col)} :  ${x}`);
      }
    }
    return results;
  })();
  return str.join('\n');
};

module.exports = function(data, options = {}) {
  var badFiles, bl, d, f, ref, result;
  if (((ref = options.keys) != null ? ref.length : void 0) === 1 && !options.reportDetails) {
    return data.summary[options.keys[0]];
  }
  if (options.keys == null) {
    options.keys = sloc.keys;
  }
  result = `\n---------- ${i18n.en.Result} ------------\n\n`;
  result += stat({
    stats: data.summary
  }, options);
  badFiles = data.files.filter(function(x) {
    return x.badFile;
  });
  result += `\n\n${i18n.en.NumberOfFilesRead} :  ${data.files.length - badFiles.length}`;
  if (bl = badFiles.length > 0) {
    result += `\n${align(i18n.en.Brokenfiles, col)} :  ${badFiles.length}`;
  }
  if (options.details && data.files.length > 1) {
    result += `\n\n---------- ${i18n.en.Details} -----------\n`;
    d = (function() {
      var i, len, ref1, results;
      ref1 = data.files;
      results = [];
      for (i = 0, len = ref1.length; i < len; i++) {
        f = ref1[i];
        results.push(`\n\n--- ${f.path}\n\n${stat(f, options)}`);
      }
      return results;
    })();
    result += d.join('');
  }
  return result += "\n\n------------------------------\n";
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var align, col, helpers, i18n, sloc, stat;

sloc = require('../sloc');

i18n = require('../i18n');

helpers = require('../helpers');

align = helpers.alignRight;

col = 20;

stat = function(data, options) {
  var k, str, x;
  if (data.badFile) {
    return `${align(i18n.en.Error, col)} :  ${i18n.en.BadFile}`;
  }
  str = (function() {
    var i, len, ref, results;
    ref = options.keys;
    results = [];
    for (i = 0, len = ref.length; i < len; i++) {
      k = ref[i];
      if ((x = data.stats[k]) != null) {
        results.push(`${align(i18n.en[k], col)} :  ${x}`);
      }
    }
    return results;
  })();
  return str.join('\n');
};

module.exports = function(data, options = {}) {
  var badFiles, bl, d, f, ref, result;
  if (((ref = options.keys) != null ? ref.length : void 0) === 1 && !options.reportDetails) {
    return data.summary[options.keys[0]];
  }
  if (options.keys == null) {
    options.keys = sloc.keys;
  }
  result = `\n---------- ${i18n.en.Result} ------------\n\n`;
  result += stat({
    stats: data.summary
  }, options);
  badFiles = data.files.filter(function(x) {
    return x.badFile;
  });
  result += `\n\n${i18n.en.NumberOfFilesRead} :  ${data.files.length - badFiles.length}`;
  if (bl = badFiles.length > 0) {
    result += `\n${align(i18n.en.Brokenfiles, col)} :  ${badFiles.length}`;
  }
  if (options.details && data.files.length > 1) {
    result += `\n\n---------- ${i18n.en.Details} -----------\n`;
    d = (function() {
      var i, len, ref1, results;
      ref1 = data.files;
      results = [];
      for (i = 0, len = ref1.length; i < len; i++) {
        f = ref1[i];
        results.push(`\n\n--- ${f.path}\n\n${stat(f, options)}`);
      }
      return results;
    })();
    result += d.join('');
  }
  return result += "\n\n------------------------------\n";
};
```

Response:
sloc    = require '../sloc'
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

stat = (data, options) ->

  if data.badFile
    return "#{align i18n.en.Error, col} :  #{i18n.en.BadFile}"

  str = for k in options.keys when (x = data.stats[k])?
    "#{align i18n.en[k], col} :  #{x}"

  str.join '\n'

module.exports = (data, options={}) ->

  if options.keys?.length is 1 and not options.reportDetails
    return data.summary[options.keys[0]]

  if not options.keys?
    options.keys = sloc.keys

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat {stats: data.summary}, options

  badFiles = data.files.filter (x) -> x.badFile

  result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.files.length - badFiles.length}"

  if bl = badFiles.length > 0
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{badFiles.length}"

  if options.details and data.files.length > 1
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for f in data.files
      "\n\n--- #{f.path}\n\n#{stat f, options}"

    result += d.join ''

  result += "\n\n------------------------------\n"


Prompt:
sloc    = require '../sloc'
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

stat = (data, options) ->

  if data.badFile
    return "#{align i18n.en.Error, col} :  #{i18n.en.BadFile}"

  str = for k in options.keys when (x = data.stats[k])?
    "#{align i18n.en[k], col} :  #{x}"

  str.join '\n'

module.exports = (data, options={}) ->

  if options.keys?.length is 1 and not options.reportDetails
    return data.summary[options.keys[0]]

Response:
if not options.keys?
    options.keys = sloc.keys

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat {stats: data.summary}, options

  badFiles = data.files.filter (x) -> x.badFile

  result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.files.length - badFiles.length}"

  if bl = badFiles.length > 0
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{badFiles.length}"

  if options.details and data.files.length > 1
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for f in data.files
      "\n\n--- #{f.path}\n\n#{stat f, options}"

    result += d.join ''

  result += "\n\n------------------------------\n"


Response:
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

BAD_FILE    = i18n.en.BadFile
BAD_FORMAT  = i18n.en.BadFormat
BAD_DIR     = i18n.en.BadDir

stat = (data, options={}) ->

  if data.err
    return "#{align i18n.en.Error, col} :  #{data.err}"

  if options.sloc
   return data.sloc

  """
  #{align i18n.en.loc,   col} :  #{data.loc}
  #{align i18n.en.sloc,  col} :  #{data.sloc}
  #{align i18n.en.cloc,  col} :  #{data.cloc}
  #{align i18n.en.scloc, col} :  #{data.scloc}
  #{align i18n.en.mcloc, col} :  #{data.mcloc}
  #{align i18n.en.nloc,  col} :  #{data.nloc}
  """

module.exports = (data, options) ->

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat data, options

  if data.filesRead?
    result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.filesRead}"

  if data[BAD_FORMAT]
    result += "\n#{align i18n.en.UnknownSourceFiles, col} :  #{data[BAD_FORMAT]}"

  if data[BAD_FILE]
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{data[BAD_FILE]}"

  if data[BAD_DIR]
    result += "\n#{align i18n.en.BrokenDirectories, col} :  #{data[BAD_DIR]}"

  if data.details?
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for detail in data.details
      "\n--- #{detail.path}\n\n#{stat detail, options}\n"

    result += d.join ''


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

BAD_FILE    = i18n.en.BadFile
BAD_FORMAT  = i18n.en.BadFormat
BAD_DIR     = i18n.en.BadDir

stat = (data, options={}) ->

  if data.err
    return "#{align i18n.en.Error, col} :  #{data.err}"

  if options.sloc
   return data.sloc

  """
  #{align i18n.en.loc,   col} :  #{data.loc}
  #{align i18n.en.sloc,  col} :  #{data.sloc}
  #{align i18n.en.cloc,  col} :  #{data.cloc}
  #{align i18n.en.scloc, col} :  #{data.scloc}
  #{align i18n.en.mcloc, col} :  #{data.mcloc}
  #{align i18n.en.nloc,  col} :  #{data.nloc}
  """

module.exports = (data, options) ->

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat data, options

  if data.filesRead?
    result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.filesRead}"

  if data[BAD_FORMAT]
    result += "\n#{align i18n.en.UnknownSourceFiles, col} :  #{data[BAD_FORMAT]}"

  if data[BAD_FILE]
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{data[BAD_FILE]}"

  if data[BAD_DIR]
    result += "\n#{align i18n.en.BrokenDirectories, col} :  #{data[BAD_DIR]}"

  if data.details?
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for detail in data.details
      "\n--- #{detail.path}\n\n#{stat detail, options}\n"

    result += d.join ''
```

Response:
var BAD_DIR, BAD_FILE, BAD_FORMAT, align, col, helpers, i18n, stat;

i18n = require('../i18n');

helpers = require('../helpers');

align = helpers.alignRight;

col = 20;

BAD_FILE = i18n.en.BadFile;

BAD_FORMAT = i18n.en.BadFormat;

BAD_DIR = i18n.en.BadDir;

stat = function(data, options = {}) {
  if (data.err) {
    return `${align(i18n.en.Error, col)} :  ${data.err}`;
  }
  if (options.sloc) {
    return data.sloc;
  }
  return `${align(i18n.en.loc, col)} :  ${data.loc}
${align(i18n.en.sloc, col)} :  ${data.sloc}
${align(i18n.en.cloc, col)} :  ${data.cloc}
${align(i18n.en.scloc, col)} :  ${data.scloc}
${align(i18n.en.mcloc, col)} :  ${data.mcloc}
${align(i18n.en.nloc, col)} :  ${data.nloc}`;
};

module.exports = function(data, options) {
  var d, detail, result;
  result = `\n---------- ${i18n.en.Result} ------------\n\n`;
  result += stat(data, options);
  if (data.filesRead != null) {
    result += `\n\n${i18n.en.NumberOfFilesRead} :  ${data.filesRead}`;
  }
  if (data[BAD_FORMAT]) {
    result += `\n${align(i18n.en.UnknownSourceFiles, col)} :  ${data[BAD_FORMAT]}`;
  }
  if (data[BAD_FILE]) {
    result += `\n${align(i18n.en.Brokenfiles, col)} :  ${data[BAD_FILE]}`;
  }
  if (data[BAD_DIR]) {
    result += `\n${align(i18n.en.BrokenDirectories, col)} :  ${data[BAD_DIR]}`;
  }
  if (data.details != null) {
    result += `\n\n---------- ${i18n.en.Details} -----------\n`;
    d = (function() {
      var i, len, ref, results;
      ref = data.details;
      results = [];
      for (i = 0, len = ref.length; i < len; i++) {
        detail = ref[i];
        results.push(`\n--- ${detail.path}\n\n${stat(detail, options)}\n`);
      }
      return results;
    })();
    return result += d.join('');
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var BAD_DIR, BAD_FILE, BAD_FORMAT, align, col, helpers, i18n, stat;

i18n = require('../i18n');

helpers = require('../helpers');

align = helpers.alignRight;

col = 20;

BAD_FILE = i18n.en.BadFile;

BAD_FORMAT = i18n.en.BadFormat;

BAD_DIR = i18n.en.BadDir;

stat = function(data, options = {}) {
  if (data.err) {
    return `${align(i18n.en.Error, col)} :  ${data.err}`;
  }
  if (options.sloc) {
    return data.sloc;
  }
  return `${align(i18n.en.loc, col)} :  ${data.loc}
${align(i18n.en.sloc, col)} :  ${data.sloc}
${align(i18n.en.cloc, col)} :  ${data.cloc}
${align(i18n.en.scloc, col)} :  ${data.scloc}
${align(i18n.en.mcloc, col)} :  ${data.mcloc}
${align(i18n.en.nloc, col)} :  ${data.nloc}`;
};

module.exports = function(data, options) {
  var d, detail, result;
  result = `\n---------- ${i18n.en.Result} ------------\n\n`;
  result += stat(data, options);
  if (data.filesRead != null) {
    result += `\n\n${i18n.en.NumberOfFilesRead} :  ${data.filesRead}`;
  }
  if (data[BAD_FORMAT]) {
    result += `\n${align(i18n.en.UnknownSourceFiles, col)} :  ${data[BAD_FORMAT]}`;
  }
  if (data[BAD_FILE]) {
    result += `\n${align(i18n.en.Brokenfiles, col)} :  ${data[BAD_FILE]}`;
  }
  if (data[BAD_DIR]) {
    result += `\n${align(i18n.en.BrokenDirectories, col)} :  ${data[BAD_DIR]}`;
  }
  if (data.details != null) {
    result += `\n\n---------- ${i18n.en.Details} -----------\n`;
    d = (function() {
      var i, len, ref, results;
      ref = data.details;
      results = [];
      for (i = 0, len = ref.length; i < len; i++) {
        detail = ref[i];
        results.push(`\n--- ${detail.path}\n\n${stat(detail, options)}\n`);
      }
      return results;
    })();
    return result += d.join('');
  }
};
```

Response:
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

BAD_FILE    = i18n.en.BadFile
BAD_FORMAT  = i18n.en.BadFormat
BAD_DIR     = i18n.en.BadDir

stat = (data, options={}) ->

  if data.err
    return "#{align i18n.en.Error, col} :  #{data.err}"

  if options.sloc
   return data.sloc

  """
  #{align i18n.en.loc,   col} :  #{data.loc}
  #{align i18n.en.sloc,  col} :  #{data.sloc}
  #{align i18n.en.cloc,  col} :  #{data.cloc}
  #{align i18n.en.scloc, col} :  #{data.scloc}
  #{align i18n.en.mcloc, col} :  #{data.mcloc}
  #{align i18n.en.nloc,  col} :  #{data.nloc}
  """

module.exports = (data, options) ->

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat data, options

  if data.filesRead?
    result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.filesRead}"

  if data[BAD_FORMAT]
    result += "\n#{align i18n.en.UnknownSourceFiles, col} :  #{data[BAD_FORMAT]}"

  if data[BAD_FILE]
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{data[BAD_FILE]}"

  if data[BAD_DIR]
    result += "\n#{align i18n.en.BrokenDirectories, col} :  #{data[BAD_DIR]}"

  if data.details?
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for detail in data.details
      "\n--- #{detail.path}\n\n#{stat detail, options}\n"

    result += d.join ''


Prompt:
i18n    = require '../i18n'
helpers = require '../helpers'
align   = helpers.alignRight
col     = 20

BAD_FILE    = i18n.en.BadFile
BAD_FORMAT  = i18n.en.BadFormat
BAD_DIR     = i18n.en.BadDir

stat = (data, options={}) ->

  if data.err
    return "#{align i18n.en.Error, col} :  #{data.err}"

  if options.sloc
   return data.sloc

  """
  #{align i18n.en.loc,   col} :  #{data.loc}
  #{align i18n.en.sloc,  col} :  #{data.sloc}
  #{align i18n.en.cloc,  col} :  #{data.cloc}
  #{align i18n.en.scloc, col} :  #{data.scloc}
  #{align i18n.en.mcloc, col} :  #{data.mcloc}
  #{align i18n.en.nloc,  col} :  #{data.nloc}
  """

Response:
module.exports = (data, options) ->

  result = "\n---------- #{i18n.en.Result} ------------\n\n"

  result += stat data, options

  if data.filesRead?
    result += "\n\n#{i18n.en.NumberOfFilesRead} :  #{data.filesRead}"

  if data[BAD_FORMAT]
    result += "\n#{align i18n.en.UnknownSourceFiles, col} :  #{data[BAD_FORMAT]}"

  if data[BAD_FILE]
    result += "\n#{align i18n.en.Brokenfiles, col} :  #{data[BAD_FILE]}"

  if data[BAD_DIR]
    result += "\n#{align i18n.en.BrokenDirectories, col} :  #{data[BAD_DIR]}"

  if data.details?
    result += "\n\n---------- #{i18n.en.Details} -----------\n"
    d = for detail in data.details
      "\n--- #{detail.path}\n\n#{stat detail, options}\n"

    result += d.join ''


Response:
Swag.addHelper 'is', (value, test, options) ->
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Swag.addHelper 'is', (value, test, options) ->
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']
```

Response:
Swag.addHelper('is', function(value, test, options) {
  if (value && value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('isnt', function(value, test, options) {
  if (!value || value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Swag.addHelper('is', function(value, test, options) {
  if (value && value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('isnt', function(value, test, options) {
  if (!value || value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);
```

Response:
Swag.addHelper 'is', (value, test, options) ->
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']


Prompt:
Swag.addHelper 'is', (value, test, options) ->
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Response:
Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']


Response:
Swag.addHelper 'is', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Swag.addHelper 'is', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']
```

Response:
Swag.addHelper('is', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value && value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('isnt', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (!value || value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gt', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gte', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lt', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lte', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('or', function(testA, testB, options) {
  testA = Utils.result(testA);
  testB = Utils.result(testB);
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('and', function(testA, testB, options) {
  testA = Utils.result(testA);
  testB = Utils.result(testB);
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Swag.addHelper('is', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value && value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('isnt', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (!value || value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gt', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('gte', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lt', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('lte', function(value, test, options) {
  value = Utils.result(value);
  test = Utils.result(test);
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('or', function(testA, testB, options) {
  testA = Utils.result(testA);
  testB = Utils.result(testB);
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);

Swag.addHelper('and', function(testA, testB, options) {
  testA = Utils.result(testA);
  testB = Utils.result(testB);
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
}, ['safe:string|number', 'safe:string|number']);
```

Response:
Swag.addHelper 'is', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']


Prompt:
Swag.addHelper 'is', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value and value is test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'isnt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if not value or value isnt test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value > test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'gte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value >= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Response:
Swag.addHelper 'lt', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value < test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'lte', (value, test, options) ->
    value = Utils.result value
    test = Utils.result test
    if value <= test then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'or', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA or testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']

Swag.addHelper 'and', (testA, testB, options) ->
    testA = Utils.result testA
    testB = Utils.result testB
    if testA and testB then options.fn this else options.inverse this
, ['safe:string|number', 'safe:string|number']


Response:
Swag.addHelper 'is', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific value)
        value = Utils.result value
        test = Utils.result test
        if value and value is test then options.fn this else options.inverse this
    else
        Utils.err '{{is}} takes two arguments (string|number, string|number).'

Swag.addHelper 'isnt', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if not value or value isnt test then options.fn this else options.inverse this
    else
        Utils.err '{{isnt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gt', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value > test then options.fn this else options.inverse this
    else
        Utils.err '{{gt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gte', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value >= test then options.fn this else options.inverse this
    else
        Utils.err '{{gte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lt', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value < test then options.fn this else options.inverse this
    else
        Utils.err '{{lt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lte', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value <= test then options.fn this else options.inverse this
    else
        Utils.err '{{lte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'or', (testA, testB, options) ->
    unless (Utils.isHandlebarsSpecific testA) and (Utils.isHandlebarsSpecific testB)


Prompt:
Swag.addHelper 'is', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific value)
        value = Utils.result value
        test = Utils.result test
        if value and value is test then options.fn this else options.inverse this
    else
        Utils.err '{{is}} takes two arguments (string|number, string|number).'

Swag.addHelper 'isnt', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if not value or value isnt test then options.fn this else options.inverse this
    else
        Utils.err '{{isnt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gt', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value > test then options.fn this else options.inverse this
    else
        Utils.err '{{gt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gte', (value, test, options) ->

Response:
unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value >= test then options.fn this else options.inverse this
    else
        Utils.err '{{gte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lt', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value < test then options.fn this else options.inverse this
    else
        Utils.err '{{lt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lte', (value, test, options) ->
    unless (Utils.isHandlebarsSpecific value) and (Utils.isHandlebarsSpecific test)
        value = Utils.result value
        test = Utils.result test
        if value <= test then options.fn this else options.inverse this
    else
        Utils.err '{{lte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'or', (testA, testB, options) ->
    unless (Utils.isHandlebarsSpecific testA) and (Utils.isHandlebarsSpecific testB)


Response:
testA = Utils.result testA
        testB = Utils.result testB
        if testA or testB then options.fn this else options.inverse this
    else
        Utils.err '{{or}} takes two arguments (string|number, string|number).'

Swag.addHelper 'and', (testA, testB, options) ->
    unless (Utils.isHandlebarsSpecific testA) and (Utils.isHandlebarsSpecific testB)
        testA = Utils.result testA
        testB = Utils.result testB
        if testA and testB then options.fn this else options.inverse this
    else
        Utils.err '{{and}} takes two arguments (string|number, string|number).'


Prompt:
testA = Utils.result testA
        testB = Utils.result testB
        if testA or testB then options.fn this else options.inverse this
    else
        Utils.err '{{or}} takes two arguments (string|number, string|number).'

Response:
Swag.addHelper 'and', (testA, testB, options) ->
    unless (Utils.isHandlebarsSpecific testA) and (Utils.isHandlebarsSpecific testB)
        testA = Utils.result testA
        testB = Utils.result testB
        if testA and testB then options.fn this else options.inverse this
    else
        Utils.err '{{and}} takes two arguments (string|number, string|number).'


Response:
Swag.addHelper 'is', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined value)
        value = Utils.result value
        test = Utils.result test
        if value is test then options.fn this else options.inverse this
    else
        Utils.err '{{is}} takes two arguments (string|number, string|number).'

Swag.addHelper 'isnt', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value isnt test then options.fn this else options.inverse this
    else
        Utils.err '{{isnt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gt', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value > test then options.fn this else options.inverse this
    else
        Utils.err '{{gt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gte', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value >= test then options.fn this else options.inverse this
    else
        Utils.err '{{gte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lt', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value < test then options.fn this else options.inverse this
    else
        Utils.err '{{lt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lte', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value <= test then options.fn this else options.inverse this
    else
        Utils.err '{{lte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'or', (testA, testB, options) ->
    unless (Utils.isUndefined testA) and (Utils.isUndefined testB)


Prompt:
Swag.addHelper 'is', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined value)
        value = Utils.result value
        test = Utils.result test
        if value is test then options.fn this else options.inverse this
    else
        Utils.err '{{is}} takes two arguments (string|number, string|number).'

Swag.addHelper 'isnt', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value isnt test then options.fn this else options.inverse this
    else
        Utils.err '{{isnt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gt', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value > test then options.fn this else options.inverse this
    else
        Utils.err '{{gt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'gte', (value, test, options) ->

Response:
unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value >= test then options.fn this else options.inverse this
    else
        Utils.err '{{gte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lt', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value < test then options.fn this else options.inverse this
    else
        Utils.err '{{lt}} takes two arguments (string|number, string|number).'

Swag.addHelper 'lte', (value, test, options) ->
    unless (Utils.isUndefined value) and (Utils.isUndefined test)
        value = Utils.result value
        test = Utils.result test
        if value <= test then options.fn this else options.inverse this
    else
        Utils.err '{{lte}} takes two arguments (string|number, string|number).'

Swag.addHelper 'or', (testA, testB, options) ->
    unless (Utils.isUndefined testA) and (Utils.isUndefined testB)


Response:
testA = Utils.result testA
        testB = Utils.result testB
        if testA or testB then options.fn this else options.inverse this
    else
        Utils.err '{{or}} takes two arguments (string|number, string|number).'

Swag.addHelper 'and', (testA, testB, options) ->
    unless (Utils.isUndefined testA) and (Utils.isUndefined testB)
        testA = Utils.result testA
        testB = Utils.result testB
        if testA and testB then options.fn this else options.inverse this
    else
        Utils.err '{{and}} takes two arguments (string|number, string|number).'


Prompt:
testA = Utils.result testA
        testB = Utils.result testB
        if testA or testB then options.fn this else options.inverse this
    else
        Utils.err '{{or}} takes two arguments (string|number, string|number).'

Response:
Swag.addHelper 'and', (testA, testB, options) ->
    unless (Utils.isUndefined testA) and (Utils.isUndefined testB)
        testA = Utils.result testA
        testB = Utils.result testB
        if testA and testB then options.fn this else options.inverse this
    else
        Utils.err '{{and}} takes two arguments (string|number, string|number).'


Response:
Swag.addHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.addHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Swag.addHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.addHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)
```

Response:
Swag.addHelper('is', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('isnt', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Swag.addHelper('is', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('isnt', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.addHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});
```

Response:
Swag.addHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.addHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Swag.addHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.addHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.addHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Response:
Swag.addHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.addHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.addHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.addHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Response:
Swag.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Swag.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)
```

Response:
Swag.registerHelper('is', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('isnt', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Swag.registerHelper('is', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('isnt', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Swag.registerHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});
```

Response:
Swag.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Swag.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Response:
Swag.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Swag.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Swag.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Response:
Handlebars.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Handlebars.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)
```

Response:
Handlebars.registerHelper('is', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('isnt', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Handlebars.registerHelper('is', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('isnt', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});
```

Response:
Handlebars.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Handlebars.registerHelper 'is', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'isnt', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Response:
Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Response:
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)
```

Response:
Handlebars.registerHelper('equal', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('notEqual', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Handlebars.registerHelper('equal', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('notEqual', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('or', function(testA, testB, options) {
  if (testA || testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('and', function(testA, testB, options) {
  if (testA && testB) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});
```

Response:
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Prompt:
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Response:
Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'or', (testA, testB, options) ->
    if testA or testB then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'and', (testA, testB, options) ->
    if testA and testB then options.fn(@) else options.inverse(@)


Response:
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)
```

Response:
Handlebars.registerHelper('equal', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('notEqual', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Handlebars.registerHelper('equal', function(value, test, options) {
  if (value === test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('notEqual', function(value, test, options) {
  if (value !== test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gt', function(value, test, options) {
  if (value > test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('gte', function(value, test, options) {
  if (value >= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lt', function(value, test, options) {
  if (value < test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});

Handlebars.registerHelper('lte', function(value, test, options) {
  if (value <= test) {
    return options.fn(this);
  } else {
    return options.inverse(this);
  }
});
```

Response:
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)


Prompt:
Handlebars.registerHelper 'equal', (value, test, options) ->
    if value is test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'notEqual', (value, test, options) ->
    if value isnt test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'gt', (value, test, options) ->
    if value > test then options.fn(@) else options.inverse(@)

Response:
Handlebars.registerHelper 'gte', (value, test, options) ->
    if value >= test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lt', (value, test, options) ->
    if value < test then options.fn(@) else options.inverse(@)

Handlebars.registerHelper 'lte', (value, test, options) ->
    if value <= test then options.fn(@) else options.inverse(@)


Response:
throttle = require "lodash.throttle"
path = require "path"

module.exports =
  enable: ->
    @throttledPlayAudio = throttle @play.bind(this), 100, trailing: false

  onInput: (editor, editorElement, cursor) ->
    @throttledPlayAudio()

  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
throttle = require "lodash.throttle"
path = require "path"

module.exports =
  enable: ->
    @throttledPlayAudio = throttle @play.bind(this), 100, trailing: false

  onInput: (editor, editorElement, cursor) ->
    @throttledPlayAudio()

  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"
```

Response:
var path, throttle;

throttle = require("lodash.throttle");

path = require("path");

module.exports = {
  enable: function() {
    return this.throttledPlayAudio = throttle(this.play.bind(this), 100, {
      trailing: false
    });
  },
  onInput: function(editor, editorElement, cursor) {
    return this.throttledPlayAudio();
  },
  play: function() {
    var audio, pathtoaudio;
    if ((this.getConfig("audioclip")) === "customAudioclip") {
      pathtoaudio = this.getConfig("customAudioclip");
    } else {
      pathtoaudio = path.join(__dirname, this.getConfig("audioclip"));
    }
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var path, throttle;

throttle = require("lodash.throttle");

path = require("path");

module.exports = {
  enable: function() {
    return this.throttledPlayAudio = throttle(this.play.bind(this), 100, {
      trailing: false
    });
  },
  onInput: function(editor, editorElement, cursor) {
    return this.throttledPlayAudio();
  },
  play: function() {
    var audio, pathtoaudio;
    if ((this.getConfig("audioclip")) === "customAudioclip") {
      pathtoaudio = this.getConfig("customAudioclip");
    } else {
      pathtoaudio = path.join(__dirname, this.getConfig("audioclip"));
    }
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};
```

Response:
throttle = require "lodash.throttle"
path = require "path"

module.exports =
  enable: ->
    @throttledPlayAudio = throttle @play.bind(this), 100, trailing: false

  onInput: (editor, editorElement, cursor) ->
    @throttledPlayAudio()

  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
throttle = require "lodash.throttle"
path = require "path"

module.exports =
  enable: ->
    @throttledPlayAudio = throttle @play.bind(this), 100, trailing: false

  onInput: (editor, editorElement, cursor) ->
    @throttledPlayAudio()

  play: ->

Response:
if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Response:
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"
```

Response:
var path;

path = require("path");

module.exports = {
  play: function() {
    var audio, pathtoaudio;
    if ((this.getConfig("audioclip")) === "customAudioclip") {
      pathtoaudio = this.getConfig("customAudioclip");
    } else {
      pathtoaudio = path.join(__dirname, this.getConfig("audioclip"));
    }
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var path;

path = require("path");

module.exports = {
  play: function() {
    var audio, pathtoaudio;
    if ((this.getConfig("audioclip")) === "customAudioclip") {
      pathtoaudio = this.getConfig("customAudioclip");
    } else {
      pathtoaudio = path.join(__dirname, this.getConfig("audioclip"));
    }
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};
```

Response:
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = @getConfig "customAudioclip"
    else

Response:
pathtoaudio = path.join(__dirname, @getConfig "audioclip")
    audio = new Audio(pathtoaudio)
    audio.currentTime = 0
    audio.volume = @getConfig "volume"
    audio.play()

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Response:
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = path.join(__dirname,"../audioclips/" + @getConfig "customAudioclip")
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip");
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = path.join(__dirname,"../audioclips/" + @getConfig "customAudioclip")
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip");
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"
```

Response:
var path;

path = require("path");

module.exports = {
  play: function() {
    var audio, pathtoaudio;
    if ((this.getConfig("audioclip")) === "customAudioclip") {
      pathtoaudio = path.join(__dirname, "../audioclips/" + this.getConfig("customAudioclip"));
    } else {
      pathtoaudio = path.join(__dirname, this.getConfig("audioclip"));
    }
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var path;

path = require("path");

module.exports = {
  play: function() {
    var audio, pathtoaudio;
    if ((this.getConfig("audioclip")) === "customAudioclip") {
      pathtoaudio = path.join(__dirname, "../audioclips/" + this.getConfig("customAudioclip"));
    } else {
      pathtoaudio = path.join(__dirname, this.getConfig("audioclip"));
    }
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};
```

Response:
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = path.join(__dirname,"../audioclips/" + @getConfig "customAudioclip")
    else
      pathtoaudio = path.join(__dirname, @getConfig "audioclip");
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
path = require "path"

module.exports =
  play: ->
    if (@getConfig "audioclip") is "customAudioclip"
      pathtoaudio = path.join(__dirname,"../audioclips/" + @getConfig "customAudioclip")
    else

Response:
pathtoaudio = path.join(__dirname, @getConfig "audioclip");
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Response:
path = require "path"

module.exports =
  play: ->
    pathtoaudio = path.join(__dirname, '../audioclips/gun.wav')
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
path = require "path"

module.exports =
  play: ->
    pathtoaudio = path.join(__dirname, '../audioclips/gun.wav')
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"
```

Response:
var path;

path = require("path");

module.exports = {
  play: function() {
    var audio, pathtoaudio;
    pathtoaudio = path.join(__dirname, '../audioclips/gun.wav');
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var path;

path = require("path");

module.exports = {
  play: function() {
    var audio, pathtoaudio;
    pathtoaudio = path.join(__dirname, '../audioclips/gun.wav');
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = this.getConfig("volume");
    return audio.play();
  },
  getConfig: function(config) {
    return atom.config.get(`activate-power-mode.playAudio.${config}`);
  }
};
```

Response:
path = require "path"

module.exports =
  play: ->
    pathtoaudio = path.join(__dirname, '../audioclips/gun.wav')
    audio = new Audio(pathtoaudio);
    audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Prompt:
path = require "path"

module.exports =
  play: ->
    pathtoaudio = path.join(__dirname, '../audioclips/gun.wav')
    audio = new Audio(pathtoaudio);

Response:
audio.currentTime = 0;
    audio.volume = @getConfig "volume"
    audio.play();

  getConfig: (config) ->
    atom.config.get "activate-power-mode.playAudio.#{config}"


Response:
exports.signInRedirect = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']
  siteUrl = store.getIn ['client', 'siteUrl']
  window.location.replace (referer or siteUrl)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
exports.signInRedirect = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']
  siteUrl = store.getIn ['client', 'siteUrl']
  window.location.replace (referer or siteUrl)
```

Response:
exports.signInRedirect = function() {
  var referer, siteUrl, store;
  store = recorder.getStore();
  referer = store.getIn(['client', 'referer']);
  siteUrl = store.getIn(['client', 'siteUrl']);
  return window.location.replace(referer || siteUrl);
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
exports.signInRedirect = function() {
  var referer, siteUrl, store;
  store = recorder.getStore();
  referer = store.getIn(['client', 'referer']);
  siteUrl = store.getIn(['client', 'siteUrl']);
  return window.location.replace(referer || siteUrl);
};
```

Response:
exports.signInRedirect = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']
  siteUrl = store.getIn ['client', 'siteUrl']
  window.location.replace (referer or siteUrl)


Prompt:
exports.signInRedirect = ->
  store = recorder.getStore()

Response:
referer = store.getIn ['client', 'referer']
  siteUrl = store.getIn ['client', 'siteUrl']
  window.location.replace (referer or siteUrl)


Response:
exports.routeEmailSent = ->
  actions.routeEmailSent()
  exports.storeRefererIntoStorage()


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
exports.routeEmailSent = ->
  actions.routeEmailSent()
  exports.storeRefererIntoStorage()
```

Response:
exports.routeEmailSent = function() {
  actions.routeEmailSent();
  return exports.storeRefererIntoStorage();
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
exports.routeEmailSent = function() {
  actions.routeEmailSent();
  return exports.storeRefererIntoStorage();
};
```

Response:
exports.routeEmailSent = ->
  actions.routeEmailSent()
  exports.storeRefererIntoStorage()


Response:
exports.storeRefererIntoStorage = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']
  if referer # maybe '' or undefined
    LocalStorage.set 'referer', referer
  else
    LocalStorage.remove 'referer'


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
exports.storeRefererIntoStorage = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']
  if referer # maybe '' or undefined
    LocalStorage.set 'referer', referer
  else
    LocalStorage.remove 'referer'
```

Response:
exports.storeRefererIntoStorage = function() {
  var referer, store;
  store = recorder.getStore();
  referer = store.getIn(['client', 'referer']);
  if (referer) { // maybe '' or undefined
    return LocalStorage.set('referer', referer);
  } else {
    return LocalStorage.remove('referer');
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
exports.storeRefererIntoStorage = function() {
  var referer, store;
  store = recorder.getStore();
  referer = store.getIn(['client', 'referer']);
  if (referer) { // maybe '' or undefined
    return LocalStorage.set('referer', referer);
  } else {
    return LocalStorage.remove('referer');
  }
};
```

Response:
exports.storeRefererIntoStorage = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']
  if referer # maybe '' or undefined
    LocalStorage.set 'referer', referer
  else
    LocalStorage.remove 'referer'


Prompt:
exports.storeRefererIntoStorage = ->
  store = recorder.getStore()
  referer = store.getIn ['client', 'referer']

Response:
if referer # maybe '' or undefined
    LocalStorage.set 'referer', referer
  else
    LocalStorage.remove 'referer'


Response:
exports.takeRefererFromStorage = ->
  referer = LocalStorage.get('referer') or null
  LocalStorage.remove 'referer'
  return referer


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
exports.takeRefererFromStorage = ->
  referer = LocalStorage.get('referer') or null
  LocalStorage.remove 'referer'
  return referer
```

Response:
exports.takeRefererFromStorage = function() {
  var referer;
  referer = LocalStorage.get('referer') || null;
  LocalStorage.remove('referer');
  return referer;
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
exports.takeRefererFromStorage = function() {
  var referer;
  referer = LocalStorage.get('referer') || null;
  LocalStorage.remove('referer');
  return referer;
};
```

Response:
exports.takeRefererFromStorage = ->
  referer = LocalStorage.get('referer') or null
  LocalStorage.remove 'referer'
  return referer


Prompt:
exports.takeRefererFromStorage = ->
  referer = LocalStorage.get('referer') or null

Response:
LocalStorage.remove 'referer'
  return referer