Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var R, _;

_ = require("underscore");

R = require("../R");

R.create("EditableText", {
  propTypes: {
    value: String,
    setValue: Function
  },
  shouldComponentUpdate: function(nextProps) {
    return this._isDirty || nextProps.value !== this.props.value;
  },
  render: function() {
    var props;
    props = {
      contentEditable: true,
      onInput: this._onInput,
      onKeyDown: this._onKeyDown
    };
    _.defaults(props, this.props);
    return R.div(props);
  },
  componentDidMount: function() {
    this._refresh();
    // Autofocus if empty string value.
    if (this.props.value === "" || !this.props.value) {
      return this.getDOMNode().focus();
    }
  },
  componentDidUpdate: function() {
    return this._refresh();
  },
  _refresh: function() {
    var el;
    el = this.getDOMNode();
    if (el.textContent !== this.props.value) {
      el.textContent = this.props.value;
    }
    return this._isDirty = false;
  },
  _onInput: function() {
    var el, newValue;
    this._isDirty = true;
    el = this.getDOMNode();
    newValue = el.textContent;
    return this.props.setValue(newValue);
  },
  _onKeyDown: function(e) {
    if (e.keyCode === 13) { // Enter
      return e.preventDefault();
    }
  }
});
```

Response:
_ = require "underscore"
R = require "../R"

R.create "EditableText",
  propTypes:
    value: String
    setValue: Function

  shouldComponentUpdate: (nextProps) ->
    return @_isDirty or nextProps.value != @props.value

  render: ->
    props = {
      contentEditable: true
      onInput: @_onInput
      onKeyDown: @_onKeyDown
    }
    _.defaults(props, @props)
    R.div props

  componentDidMount: ->
    @_refresh()
    # Autofocus if empty string value.
    if @props.value == "" or !@props.value
      @getDOMNode().focus()

  componentDidUpdate: ->
    @_refresh()

  _refresh: ->
    el = @getDOMNode()
    if el.textContent != @props.value
      el.textContent = @props.value
    @_isDirty = false

  _onInput: ->
    @_isDirty = true
    el = @getDOMNode()
    newValue = el.textContent
    @props.setValue(newValue)

  _onKeyDown: (e) ->
    if e.keyCode == 13 # Enter
      e.preventDefault()


Prompt:
_ = require "underscore"
R = require "../R"

R.create "EditableText",
  propTypes:
    value: String
    setValue: Function

  shouldComponentUpdate: (nextProps) ->
    return @_isDirty or nextProps.value != @props.value

  render: ->
    props = {
      contentEditable: true
      onInput: @_onInput
      onKeyDown: @_onKeyDown
    }
    _.defaults(props, @props)
    R.div props

  componentDidMount: ->
    @_refresh()

Response:
# Autofocus if empty string value.
    if @props.value == "" or !@props.value
      @getDOMNode().focus()

  componentDidUpdate: ->
    @_refresh()

  _refresh: ->
    el = @getDOMNode()
    if el.textContent != @props.value
      el.textContent = @props.value
    @_isDirty = false

  _onInput: ->
    @_isDirty = true
    el = @getDOMNode()
    newValue = el.textContent
    @props.setValue(newValue)

  _onKeyDown: (e) ->
    if e.keyCode == 13 # Enter
      e.preventDefault()


Response:
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts), opts)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts), opts)
```

Response:
var Parser, serialise;

Parser = require('./parser');

serialise = require('./serialiser');

module.exports.transform = function(code, opts) {
  return serialise(new Parser().parse(code, opts), opts);
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var Parser, serialise;

Parser = require('./parser');

serialise = require('./serialiser');

module.exports.transform = function(code, opts) {
  return serialise(new Parser().parse(code, opts), opts);
};
```

Response:
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts), opts)


Prompt:
Parser = require './parser'
serialise = require './serialiser'

Response:
module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts), opts)


Response:
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts))


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts))
```

Response:
var Parser, serialise;

Parser = require('./parser');

serialise = require('./serialiser');

module.exports.transform = function(code, opts) {
  return serialise(new Parser().parse(code, opts));
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var Parser, serialise;

Parser = require('./parser');

serialise = require('./serialiser');

module.exports.transform = function(code, opts) {
  return serialise(new Parser().parse(code, opts));
};
```

Response:
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts))


Prompt:
Parser = require './parser'
serialise = require './serialiser'

Response:
module.exports.transform = (code, opts) ->
  serialise(new Parser().parse(code, opts))


Response:
# Import the helpers we need.
{count, starts, compact, last, repeat,
locationDataToString,  throwSyntaxError} = require './helpers'

Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise new Parser().parse code, opts


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
# Import the helpers we need.
{count, starts, compact, last, repeat,
locationDataToString,  throwSyntaxError} = require './helpers'

Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise new Parser().parse code, opts
```

Response:
// Import the helpers we need.
var Parser, compact, count, last, locationDataToString, repeat, serialise, starts, throwSyntaxError;

({count, starts, compact, last, repeat, locationDataToString, throwSyntaxError} = require('./helpers'));

Parser = require('./parser');

serialise = require('./serialiser');

module.exports.transform = function(code, opts) {
  return serialise(new Parser().parse(code, opts));
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
// Import the helpers we need.
var Parser, compact, count, last, locationDataToString, repeat, serialise, starts, throwSyntaxError;

({count, starts, compact, last, repeat, locationDataToString, throwSyntaxError} = require('./helpers'));

Parser = require('./parser');

serialise = require('./serialiser');

module.exports.transform = function(code, opts) {
  return serialise(new Parser().parse(code, opts));
};
```

Response:
# Import the helpers we need.
{count, starts, compact, last, repeat,
locationDataToString,  throwSyntaxError} = require './helpers'

Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise new Parser().parse code, opts


Prompt:
# Import the helpers we need.
{count, starts, compact, last, repeat,
locationDataToString,  throwSyntaxError} = require './helpers'

Response:
Parser = require './parser'
serialise = require './serialiser'

module.exports.transform = (code, opts) ->
  serialise new Parser().parse code, opts


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|`|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'`\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|`|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'`\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|`|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'`\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, j, len, len1, res, v, variableNamesWithPrefix, variableNamesWithoutPrefix, withPrefixes, withoutPrefixes;
    variableNamesWithPrefix = [];
    variableNamesWithoutPrefix = [];
    withPrefixes = variables.filter(function(v) {
      return !v.noNamePrefix;
    });
    withoutPrefixes = variables.filter(function(v) {
      return v.noNamePrefix;
    });
    res = [];
    if (withPrefixes.length > 0) {
      for (i = 0, len = withPrefixes.length; i < len; i++) {
        v = withPrefixes[i];
        variableNamesWithPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`((?:${namePrefixes})(${variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))`);
    }
    if (withoutPrefixes.length > 0) {
      for (j = 0, len1 = withoutPrefixes.length; j < len1; j++) {
        v = withoutPrefixes[j];
        variableNamesWithoutPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`(${variableNamesWithoutPrefix.join('|')})`);
    }
    return res.join('|');
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|`|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'`\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, j, len, len1, res, v, variableNamesWithPrefix, variableNamesWithoutPrefix, withPrefixes, withoutPrefixes;
    variableNamesWithPrefix = [];
    variableNamesWithoutPrefix = [];
    withPrefixes = variables.filter(function(v) {
      return !v.noNamePrefix;
    });
    withoutPrefixes = variables.filter(function(v) {
      return v.noNamePrefix;
    });
    res = [];
    if (withPrefixes.length > 0) {
      for (i = 0, len = withPrefixes.length; i < len; i++) {
        v = withPrefixes[i];
        variableNamesWithPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`((?:${namePrefixes})(${variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))`);
    }
    if (withoutPrefixes.length > 0) {
      for (j = 0, len1 = withoutPrefixes.length; j < len1; j++) {
        v = withoutPrefixes[j];
        variableNamesWithoutPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`(${variableNamesWithoutPrefix.join('|')})`);
    }
    return res.join('|');
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|`|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'`\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|`|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'`\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes

Response:
createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, j, len, len1, res, v, variableNamesWithPrefix, variableNamesWithoutPrefix, withPrefixes, withoutPrefixes;
    variableNamesWithPrefix = [];
    variableNamesWithoutPrefix = [];
    withPrefixes = variables.filter(function(v) {
      return !v.noNamePrefix;
    });
    withoutPrefixes = variables.filter(function(v) {
      return v.noNamePrefix;
    });
    res = [];
    if (withPrefixes.length > 0) {
      for (i = 0, len = withPrefixes.length; i < len; i++) {
        v = withPrefixes[i];
        variableNamesWithPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`((?:${namePrefixes})(${variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))`);
    }
    if (withoutPrefixes.length > 0) {
      for (j = 0, len1 = withoutPrefixes.length; j < len1; j++) {
        v = withoutPrefixes[j];
        variableNamesWithoutPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`(${variableNamesWithoutPrefix.join('|')})`);
    }
    return res.join('|');
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, j, len, len1, res, v, variableNamesWithPrefix, variableNamesWithoutPrefix, withPrefixes, withoutPrefixes;
    variableNamesWithPrefix = [];
    variableNamesWithoutPrefix = [];
    withPrefixes = variables.filter(function(v) {
      return !v.noNamePrefix;
    });
    withoutPrefixes = variables.filter(function(v) {
      return v.noNamePrefix;
    });
    res = [];
    if (withPrefixes.length > 0) {
      for (i = 0, len = withPrefixes.length; i < len; i++) {
        v = withPrefixes[i];
        variableNamesWithPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`((?:${namePrefixes})(${variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))`);
    }
    if (withoutPrefixes.length > 0) {
      for (j = 0, len1 = withoutPrefixes.length; j < len1; j++) {
        v = withoutPrefixes[j];
        variableNamesWithoutPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
      }
      res.push(`(${variableNamesWithoutPrefix.join('|')})`);
    }
    return res.join('|');
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes

Response:
createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    res = []

    if withPrefixes.length > 0
      for v in withPrefixes
        variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))"

    if withoutPrefixes.length > 0
      for v in withoutPrefixes
        variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

      res.push "(#{variableNamesWithoutPrefix.join('|')})"

    res.join('|')


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    for v in withPrefixes
      variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    for v in withoutPrefixes
      variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))|(#{variableNamesWithoutPrefix.join('|')})"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    for v in withPrefixes
      variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    for v in withoutPrefixes
      variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))|(#{variableNamesWithoutPrefix.join('|')})"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, j, len, len1, v, variableNamesWithPrefix, variableNamesWithoutPrefix, withPrefixes, withoutPrefixes;
    variableNamesWithPrefix = [];
    variableNamesWithoutPrefix = [];
    withPrefixes = variables.filter(function(v) {
      return !v.noNamePrefix;
    });
    withoutPrefixes = variables.filter(function(v) {
      return v.noNamePrefix;
    });
    for (i = 0, len = withPrefixes.length; i < len; i++) {
      v = withPrefixes[i];
      variableNamesWithPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    for (j = 0, len1 = withoutPrefixes.length; j < len1; j++) {
      v = withoutPrefixes[j];
      variableNamesWithoutPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    return `((?:${namePrefixes})(${variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))|(${variableNamesWithoutPrefix.join('|')})`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, j, len, len1, v, variableNamesWithPrefix, variableNamesWithoutPrefix, withPrefixes, withoutPrefixes;
    variableNamesWithPrefix = [];
    variableNamesWithoutPrefix = [];
    withPrefixes = variables.filter(function(v) {
      return !v.noNamePrefix;
    });
    withoutPrefixes = variables.filter(function(v) {
      return v.noNamePrefix;
    });
    for (i = 0, len = withPrefixes.length; i < len; i++) {
      v = withPrefixes[i];
      variableNamesWithPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    for (j = 0, len1 = withoutPrefixes.length; j < len1; j++) {
      v = withoutPrefixes[j];
      variableNamesWithoutPrefix.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    return `((?:${namePrefixes})(${variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))|(${variableNamesWithoutPrefix.join('|')})`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    for v in withPrefixes
      variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    for v in withoutPrefixes
      variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))|(#{variableNamesWithoutPrefix.join('|')})"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'

Response:
ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNamesWithPrefix = []
    variableNamesWithoutPrefix = []
    withPrefixes = variables.filter (v) -> not v.noNamePrefix
    withoutPrefixes = variables.filter (v) -> v.noNamePrefix

    for v in withPrefixes
      variableNamesWithPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    for v in withoutPrefixes
      variableNamesWithoutPrefix.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")

    "((?:#{namePrefixes})(#{variableNamesWithPrefix.join('|')})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=]))|(#{variableNamesWithoutPrefix.join('|')})"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{|>'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(\\s+!default)?(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n\\r]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n\\r]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |\\t|:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}${decimal}|${int}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}#{decimal}|#{int}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}|${int}${decimal}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}|${int}${decimal}|${decimal})`;

percent = `${float}%`;

variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(?:${percent}|${int})`,
  floatOrPercent: `(?:${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(?:${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(?:@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(?:#{percent}|#{int})"
  floatOrPercent: "(?:#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(?:#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(#{percent}|#{int})"
  floatOrPercent: "(#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(#{percent}|#{int})"
  floatOrPercent: "(#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"
```

Response:
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}|${int}${decimal}|${decimal})`;

percent = `${float}%`;

variables = '(@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(${percent}|${int})`,
  floatOrPercent: `(${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var decimal, float, int, namePrefixes, percent, variables;

int = '\\d+';

decimal = `\\.${int}`;

float = `(?:${int}|${int}${decimal}|${decimal})`;

percent = `${float}%`;

variables = '(@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)';

namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{';

module.exports = {
  int: int,
  float: float,
  percent: percent,
  optionalPercent: `${float}%?`,
  intOrPercent: `(${percent}|${int})`,
  floatOrPercent: `(${percent}|${float})`,
  comma: '\\s*,\\s*',
  notQuote: "[^\"'\\n]+",
  hexadecimal: '[\\da-fA-F]',
  ps: '\\(\\s*',
  pe: '\\s*\\)',
  variables: variables,
  namePrefixes: namePrefixes,
  createVariableRegExpString: function(variables) {
    var i, len, v, variableNames;
    variableNames = [];
    for (i = 0, len = variables.length; i < len; i++) {
      v = variables[i];
      variableNames.push(v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"));
    }
    variableNames = variableNames.join('|');
    return `(${namePrefixes})(${variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])`;
  }
};
```

Response:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(#{percent}|#{int})"
  floatOrPercent: "(#{percent}|#{float})"
  comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Prompt:
int = '\\d+'
decimal = "\\.#{int}"
float = "(?:#{int}|#{int}#{decimal}|#{decimal})"
percent = "#{float}%"
variables = '(@[a-zA-Z0-9\\-_]+|\\$[a-zA-Z0-9\\-_]+|[a-zA-Z_][a-zA-Z0-9\\-_]*)'
namePrefixes = '^| |:|=|,|\\n|\'|"|\\(|\\[|\\{'

module.exports =
  int: int
  float: float
  percent: percent
  optionalPercent: "#{float}%?"
  intOrPercent: "(#{percent}|#{int})"
  floatOrPercent: "(#{percent}|#{float})"

Response:
comma: '\\s*,\\s*'
  notQuote: "[^\"'\\n]+"
  hexadecimal: '[\\da-fA-F]'
  ps: '\\(\\s*'
  pe: '\\s*\\)'
  variables: variables
  namePrefixes: namePrefixes
  createVariableRegExpString: (variables) ->
    variableNames = []
    for v in variables
      variableNames.push v.name.replace(/[-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&")
    variableNames = variableNames.join('|')

    "(#{namePrefixes})(#{variableNames})(?!_|-|\\w|\\d|[ \\t]*[\\.:=])"


Response:
Houston._setup_collection = (collection) ->
  name = collection._name
  return if name of ADDED_COLLECTIONS

  Houston._setup_collection_methods(collection)

  Houston._publish name, (sort, filter, limit, unknown_arg) ->
    check sort, Match.Optional(Object)
    check filter, Match.Optional(Object)
    check limit, Match.Optional(Number)
    check unknown_arg, Match.Any
    unless Houston._user_is_admin @userId
      @ready()
      return
    try
      collection.find(filter, sort: sort, limit: limit)
    catch e
      console.log e

  collection.find().observe
    _suppress_initial: true  # fixes houston for large initial datasets
    added: (document) ->
      Houston._collections.collections.update {name},
        $inc: {count: 1},
        $addToSet: fields: $each: Houston._get_fields([document])
    changed: (document) ->
      Houston._collections.collections.update {name},
        $addToSet: fields: $each: Houston._get_fields([document])
    removed: (document) ->
      Houston._collections.collections.update {name}, {$inc: {count: -1}}

  fields = Houston._get_fields_from_collection(collection)
  c = Houston._collections.collections.findOne {name}
  count = collection.find().count()
  if c
    Houston._collections.collections.update c._id, {$set: {count, fields}}
  else
    Houston._collections.collections.insert {name, count, fields}
  ADDED_COLLECTIONS[name] = collection


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
Houston._setup_collection = (collection) ->
  name = collection._name
  return if name of ADDED_COLLECTIONS

  Houston._setup_collection_methods(collection)

  Houston._publish name, (sort, filter, limit, unknown_arg) ->
    check sort, Match.Optional(Object)
    check filter, Match.Optional(Object)
    check limit, Match.Optional(Number)
    check unknown_arg, Match.Any
    unless Houston._user_is_admin @userId
      @ready()
      return
    try
      collection.find(filter, sort: sort, limit: limit)
    catch e
      console.log e

  collection.find().observe
    _suppress_initial: true  # fixes houston for large initial datasets
    added: (document) ->
      Houston._collections.collections.update {name},
        $inc: {count: 1},
        $addToSet: fields: $each: Houston._get_fields([document])
    changed: (document) ->
      Houston._collections.collections.update {name},
        $addToSet: fields: $each: Houston._get_fields([document])
    removed: (document) ->
      Houston._collections.collections.update {name}, {$inc: {count: -1}}

  fields = Houston._get_fields_from_collection(collection)
  c = Houston._collections.collections.findOne {name}
  count = collection.find().count()
  if c
    Houston._collections.collections.update c._id, {$set: {count, fields}}
  else
    Houston._collections.collections.insert {name, count, fields}
  ADDED_COLLECTIONS[name] = collection
```

Response:
Houston._setup_collection = function(collection) {
  var c, count, fields, name;
  name = collection._name;
  if (name in ADDED_COLLECTIONS) {
    return;
  }
  Houston._setup_collection_methods(collection);
  Houston._publish(name, function(sort, filter, limit, unknown_arg) {
    var e;
    check(sort, Match.Optional(Object));
    check(filter, Match.Optional(Object));
    check(limit, Match.Optional(Number));
    check(unknown_arg, Match.Any);
    if (!Houston._user_is_admin(this.userId)) {
      this.ready();
      return;
    }
    try {
      return collection.find(filter, {
        sort: sort,
        limit: limit
      });
    } catch (error) {
      e = error;
      return console.log(e);
    }
  });
  collection.find().observe({
    _suppress_initial: true, // fixes houston for large initial datasets
    added: function(document) {
      return Houston._collections.collections.update({name}, {
        $inc: {
          count: 1
        },
        $addToSet: {
          fields: {
            $each: Houston._get_fields([document])
          }
        }
      });
    },
    changed: function(document) {
      return Houston._collections.collections.update({name}, {
        $addToSet: {
          fields: {
            $each: Houston._get_fields([document])
          }
        }
      });
    },
    removed: function(document) {
      return Houston._collections.collections.update({name}, {
        $inc: {
          count: -1
        }
      });
    }
  });
  fields = Houston._get_fields_from_collection(collection);
  c = Houston._collections.collections.findOne({name});
  count = collection.find().count();
  if (c) {
    Houston._collections.collections.update(c._id, {
      $set: {count, fields}
    });
  } else {
    Houston._collections.collections.insert({name, count, fields});
  }
  return ADDED_COLLECTIONS[name] = collection;
};


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
Houston._setup_collection = function(collection) {
  var c, count, fields, name;
  name = collection._name;
  if (name in ADDED_COLLECTIONS) {
    return;
  }
  Houston._setup_collection_methods(collection);
  Houston._publish(name, function(sort, filter, limit, unknown_arg) {
    var e;
    check(sort, Match.Optional(Object));
    check(filter, Match.Optional(Object));
    check(limit, Match.Optional(Number));
    check(unknown_arg, Match.Any);
    if (!Houston._user_is_admin(this.userId)) {
      this.ready();
      return;
    }
    try {
      return collection.find(filter, {
        sort: sort,
        limit: limit
      });
    } catch (error) {
      e = error;
      return console.log(e);
    }
  });
  collection.find().observe({
    _suppress_initial: true, // fixes houston for large initial datasets
    added: function(document) {
      return Houston._collections.collections.update({name}, {
        $inc: {
          count: 1
        },
        $addToSet: {
          fields: {
            $each: Houston._get_fields([document])
          }
        }
      });
    },
    changed: function(document) {
      return Houston._collections.collections.update({name}, {
        $addToSet: {
          fields: {
            $each: Houston._get_fields([document])
          }
        }
      });
    },
    removed: function(document) {
      return Houston._collections.collections.update({name}, {
        $inc: {
          count: -1
        }
      });
    }
  });
  fields = Houston._get_fields_from_collection(collection);
  c = Houston._collections.collections.findOne({name});
  count = collection.find().count();
  if (c) {
    Houston._collections.collections.update(c._id, {
      $set: {count, fields}
    });
  } else {
    Houston._collections.collections.insert({name, count, fields});
  }
  return ADDED_COLLECTIONS[name] = collection;
};
```

Response:
Houston._setup_collection = (collection) ->
  name = collection._name
  return if name of ADDED_COLLECTIONS

  Houston._setup_collection_methods(collection)

  Houston._publish name, (sort, filter, limit, unknown_arg) ->
    check sort, Match.Optional(Object)
    check filter, Match.Optional(Object)
    check limit, Match.Optional(Number)
    check unknown_arg, Match.Any
    unless Houston._user_is_admin @userId
      @ready()
      return
    try
      collection.find(filter, sort: sort, limit: limit)
    catch e
      console.log e

  collection.find().observe
    _suppress_initial: true  # fixes houston for large initial datasets
    added: (document) ->
      Houston._collections.collections.update {name},
        $inc: {count: 1},
        $addToSet: fields: $each: Houston._get_fields([document])
    changed: (document) ->
      Houston._collections.collections.update {name},
        $addToSet: fields: $each: Houston._get_fields([document])
    removed: (document) ->
      Houston._collections.collections.update {name}, {$inc: {count: -1}}

  fields = Houston._get_fields_from_collection(collection)
  c = Houston._collections.collections.findOne {name}
  count = collection.find().count()
  if c
    Houston._collections.collections.update c._id, {$set: {count, fields}}
  else
    Houston._collections.collections.insert {name, count, fields}
  ADDED_COLLECTIONS[name] = collection


Prompt:
Houston._setup_collection = (collection) ->
  name = collection._name
  return if name of ADDED_COLLECTIONS

  Houston._setup_collection_methods(collection)

  Houston._publish name, (sort, filter, limit, unknown_arg) ->
    check sort, Match.Optional(Object)
    check filter, Match.Optional(Object)
    check limit, Match.Optional(Number)
    check unknown_arg, Match.Any
    unless Houston._user_is_admin @userId
      @ready()
      return
    try
      collection.find(filter, sort: sort, limit: limit)
    catch e
      console.log e

Response:
collection.find().observe
    _suppress_initial: true  # fixes houston for large initial datasets
    added: (document) ->
      Houston._collections.collections.update {name},
        $inc: {count: 1},
        $addToSet: fields: $each: Houston._get_fields([document])
    changed: (document) ->
      Houston._collections.collections.update {name},
        $addToSet: fields: $each: Houston._get_fields([document])
    removed: (document) ->
      Houston._collections.collections.update {name}, {$inc: {count: -1}}

  fields = Houston._get_fields_from_collection(collection)
  c = Houston._collections.collections.findOne {name}
  count = collection.find().count()
  if c
    Houston._collections.collections.update c._id, {$set: {count, fields}}
  else
    Houston._collections.collections.insert {name, count, fields}
  ADDED_COLLECTIONS[name] = collection


Response:
sync_collections = ->
  Houston._admins.findOne() # TODO Why is this here?

  collections = {}
  for collection in (Mongo.Collection.getAll() ? [])
    collections[collection.name] = collection.instance

  _sync_collections = (meh, collections_db) ->
    collection_names = (col.collectionName for col in collections_db \
      when (col.collectionName.indexOf "system.") isnt 0 and
           (col.collectionName.indexOf "houston_") isnt 0)

    collection_names.forEach (name) ->
      unless name of ADDED_COLLECTIONS or name of Houston._HIDDEN_COLLECTIONS
        Houston._setup_collection(collections[name]) if collections[name]?

  bound_sync_collections = Meteor.bindEnvironment _sync_collections, (e) ->
    console.log "Failed while syncing collections for reason: #{e}"

  # MongoInternals is the 'right' solution as of 0.6.5
  mongo_driver = MongoInternals?.defaultRemoteCollectionDriver() or Meteor._RemoteCollectionDriver
  mongo_driver.mongo.db.collections bound_sync_collections

Meteor.methods
  _houston_make_admin: (user_id) ->
    check user_id, String
    # limit one admin
    return if Houston._admins.findOne {'user_id': $exists: true}
    Houston._admins.insert {user_id}
    Houston._admins.insert {exists: true}
    sync_collections() # reloads collections in case of new app
    return true

# publish our analysis of the app's collections
Houston._publish 'collections', ->
  unless Houston._user_is_admin @userId
    @ready()
    return
  Houston._collections.collections.find()

# TODO address inherent security issue
Houston._publish 'admin_user', ->
  unless Houston._user_is_admin @userId
    return Houston._admins.find {exists: true}
  return Houston._admins.find {}

Meteor.startup ->
  sync_collections()
  if Houston._admins.find().count() > 0 and !Houston._admins.findOne({exists: true})
    Houston._admins.insert {exists: true}


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
sync_collections = ->
  Houston._admins.findOne() # TODO Why is this here?

  collections = {}
  for collection in (Mongo.Collection.getAll() ? [])
    collections[collection.name] = collection.instance

  _sync_collections = (meh, collections_db) ->
    collection_names = (col.collectionName for col in collections_db \
      when (col.collectionName.indexOf "system.") isnt 0 and
           (col.collectionName.indexOf "houston_") isnt 0)

    collection_names.forEach (name) ->
      unless name of ADDED_COLLECTIONS or name of Houston._HIDDEN_COLLECTIONS
        Houston._setup_collection(collections[name]) if collections[name]?

  bound_sync_collections = Meteor.bindEnvironment _sync_collections, (e) ->
    console.log "Failed while syncing collections for reason: #{e}"

  # MongoInternals is the 'right' solution as of 0.6.5
  mongo_driver = MongoInternals?.defaultRemoteCollectionDriver() or Meteor._RemoteCollectionDriver
  mongo_driver.mongo.db.collections bound_sync_collections

Meteor.methods
  _houston_make_admin: (user_id) ->
    check user_id, String
    # limit one admin
    return if Houston._admins.findOne {'user_id': $exists: true}
    Houston._admins.insert {user_id}
    Houston._admins.insert {exists: true}
    sync_collections() # reloads collections in case of new app
    return true

# publish our analysis of the app's collections
Houston._publish 'collections', ->
  unless Houston._user_is_admin @userId
    @ready()
    return
  Houston._collections.collections.find()

# TODO address inherent security issue
Houston._publish 'admin_user', ->
  unless Houston._user_is_admin @userId
    return Houston._admins.find {exists: true}
  return Houston._admins.find {}

Meteor.startup ->
  sync_collections()
  if Houston._admins.find().count() > 0 and !Houston._admins.findOne({exists: true})
    Houston._admins.insert {exists: true}
```

Response:
var sync_collections;

sync_collections = function() {
  var _sync_collections, bound_sync_collections, collection, collections, i, len, mongo_driver, ref, ref1;
  Houston._admins.findOne(); // TODO Why is this here?
  collections = {};
  ref1 = (ref = Mongo.Collection.getAll()) != null ? ref : [];
  for (i = 0, len = ref1.length; i < len; i++) {
    collection = ref1[i];
    collections[collection.name] = collection.instance;
  }
  _sync_collections = function(meh, collections_db) {
    var col, collection_names;
    collection_names = (function() {
      var j, len1, results;
      results = [];
      for (j = 0, len1 = collections_db.length; j < len1; j++) {
        col = collections_db[j];
        if ((col.collectionName.indexOf("system.")) !== 0 && (col.collectionName.indexOf("houston_")) !== 0) {
          results.push(col.collectionName);
        }
      }
      return results;
    })();
    return collection_names.forEach(function(name) {
      if (!(name in ADDED_COLLECTIONS || name in Houston._HIDDEN_COLLECTIONS)) {
        if (collections[name] != null) {
          return Houston._setup_collection(collections[name]);
        }
      }
    });
  };
  bound_sync_collections = Meteor.bindEnvironment(_sync_collections, function(e) {
    return console.log(`Failed while syncing collections for reason: ${e}`);
  });
  // MongoInternals is the 'right' solution as of 0.6.5
  mongo_driver = (typeof MongoInternals !== "undefined" && MongoInternals !== null ? MongoInternals.defaultRemoteCollectionDriver() : void 0) || Meteor._RemoteCollectionDriver;
  return mongo_driver.mongo.db.collections(bound_sync_collections);
};

Meteor.methods({
  _houston_make_admin: function(user_id) {
    check(user_id, String);
    // limit one admin
    if (Houston._admins.findOne({
      'user_id': {
        $exists: true
      }
    })) {
      return;
    }
    Houston._admins.insert({user_id});
    Houston._admins.insert({
      exists: true
    });
    sync_collections(); // reloads collections in case of new app
    return true;
  }
});

// publish our analysis of the app's collections
Houston._publish('collections', function() {
  if (!Houston._user_is_admin(this.userId)) {
    this.ready();
    return;
  }
  return Houston._collections.collections.find();
});

// TODO address inherent security issue
Houston._publish('admin_user', function() {
  if (!Houston._user_is_admin(this.userId)) {
    return Houston._admins.find({
      exists: true
    });
  }
  return Houston._admins.find({});
});

Meteor.startup(function() {
  sync_collections();
  if (Houston._admins.find().count() > 0 && !Houston._admins.findOne({
    exists: true
  })) {
    return Houston._admins.insert({
      exists: true
    });
  }
});


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

sync_collections = function() {
  var _sync_collections, bound_sync_collections, collection, collections, i, len, mongo_driver, ref, ref1;
  Houston._admins.findOne(); // TODO Why is this here?
  collections = {};
  ref1 = (ref = Mongo.Collection.getAll()) != null ? ref : [];
  for (i = 0, len = ref1.length; i < len; i++) {
    collection = ref1[i];
    collections[collection.name] = collection.instance;
  }
  _sync_collections = function(meh, collections_db) {
    var col, collection_names;
    collection_names = (function() {
      var j, len1, results;
      results = [];
      for (j = 0, len1 = collections_db.length; j < len1; j++) {
        col = collections_db[j];
        if ((col.collectionName.indexOf("system.")) !== 0 && (col.collectionName.indexOf("houston_")) !== 0) {
          results.push(col.collectionName);
        }
      }
      return results;
    })();
    return collection_names.forEach(function(name) {
      if (!(name in ADDED_COLLECTIONS || name in Houston._HIDDEN_COLLECTIONS)) {
        if (collections[name] != null) {
          return Houston._setup_collection(collections[name]);
        }
      }
    });
  };
  bound_sync_collections = Meteor.bindEnvironment(_sync_collections, function(e) {
    return console.log(`Failed while syncing collections for reason: ${e}`);
  });
  // MongoInternals is the 'right' solution as of 0.6.5
  mongo_driver = (typeof MongoInternals !== "undefined" && MongoInternals !== null ? MongoInternals.defaultRemoteCollectionDriver() : void 0) || Meteor._RemoteCollectionDriver;
  return mongo_driver.mongo.db.collections(bound_sync_collections);
};

Meteor.methods({
  _houston_make_admin: function(user_id) {
    check(user_id, String);
    // limit one admin
    if (Houston._admins.findOne({
      'user_id': {
        $exists: true
      }
    })) {
      return;
    }
    Houston._admins.insert({user_id});
    Houston._admins.insert({
      exists: true
    });
    sync_collections(); // reloads collections in case of new app
    return true;
  }
});

// publish our analysis of the app's collections
Houston._publish('collections', function() {
  if (!Houston._user_is_admin(this.userId)) {
    this.ready();
    return;
  }
  return Houston._collections.collections.find();
});

// TODO address inherent security issue
Houston._publish('admin_user', function() {
  if (!Houston._user_is_admin(this.userId)) {
    return Houston._admins.find({
      exists: true
    });
  }
  return Houston._admins.find({});
});

Meteor.startup(function() {
  sync_collections();
  if (Houston._admins.find().count() > 0 && !Houston._admins.findOne({
    exists: true
  })) {
    return Houston._admins.insert({
      exists: true
    });
  }
});
```

Response:
sync_collections = ->
  Houston._admins.findOne() # TODO Why is this here?

  collections = {}
  for collection in (Mongo.Collection.getAll() ? [])
    collections[collection.name] = collection.instance

  _sync_collections = (meh, collections_db) ->
    collection_names = (col.collectionName for col in collections_db \
      when (col.collectionName.indexOf "system.") isnt 0 and
           (col.collectionName.indexOf "houston_") isnt 0)

    collection_names.forEach (name) ->
      unless name of ADDED_COLLECTIONS or name of Houston._HIDDEN_COLLECTIONS
        Houston._setup_collection(collections[name]) if collections[name]?

  bound_sync_collections = Meteor.bindEnvironment _sync_collections, (e) ->
    console.log "Failed while syncing collections for reason: #{e}"

  # MongoInternals is the 'right' solution as of 0.6.5
  mongo_driver = MongoInternals?.defaultRemoteCollectionDriver() or Meteor._RemoteCollectionDriver
  mongo_driver.mongo.db.collections bound_sync_collections

Meteor.methods
  _houston_make_admin: (user_id) ->
    check user_id, String
    # limit one admin
    return if Houston._admins.findOne {'user_id': $exists: true}
    Houston._admins.insert {user_id}
    Houston._admins.insert {exists: true}
    sync_collections() # reloads collections in case of new app
    return true

# publish our analysis of the app's collections
Houston._publish 'collections', ->
  unless Houston._user_is_admin @userId
    @ready()
    return
  Houston._collections.collections.find()

# TODO address inherent security issue
Houston._publish 'admin_user', ->
  unless Houston._user_is_admin @userId
    return Houston._admins.find {exists: true}
  return Houston._admins.find {}

Meteor.startup ->
  sync_collections()
  if Houston._admins.find().count() > 0 and !Houston._admins.findOne({exists: true})
    Houston._admins.insert {exists: true}


Prompt:
sync_collections = ->
  Houston._admins.findOne() # TODO Why is this here?

  collections = {}
  for collection in (Mongo.Collection.getAll() ? [])
    collections[collection.name] = collection.instance

  _sync_collections = (meh, collections_db) ->
    collection_names = (col.collectionName for col in collections_db \
      when (col.collectionName.indexOf "system.") isnt 0 and
           (col.collectionName.indexOf "houston_") isnt 0)

    collection_names.forEach (name) ->
      unless name of ADDED_COLLECTIONS or name of Houston._HIDDEN_COLLECTIONS
        Houston._setup_collection(collections[name]) if collections[name]?

  bound_sync_collections = Meteor.bindEnvironment _sync_collections, (e) ->
    console.log "Failed while syncing collections for reason: #{e}"

  # MongoInternals is the 'right' solution as of 0.6.5
  mongo_driver = MongoInternals?.defaultRemoteCollectionDriver() or Meteor._RemoteCollectionDriver
  mongo_driver.mongo.db.collections bound_sync_collections

Meteor.methods
  _houston_make_admin: (user_id) ->

Response:
check user_id, String
    # limit one admin
    return if Houston._admins.findOne {'user_id': $exists: true}
    Houston._admins.insert {user_id}
    Houston._admins.insert {exists: true}
    sync_collections() # reloads collections in case of new app
    return true

# publish our analysis of the app's collections
Houston._publish 'collections', ->
  unless Houston._user_is_admin @userId
    @ready()
    return
  Houston._collections.collections.find()

# TODO address inherent security issue
Houston._publish 'admin_user', ->
  unless Houston._user_is_admin @userId
    return Houston._admins.find {exists: true}
  return Houston._admins.find {}

Meteor.startup ->
  sync_collections()
  if Houston._admins.find().count() > 0 and !Houston._admins.findOne({exists: true})
    Houston._admins.insert {exists: true}