Prompt:
describe "InsertLastInserted", ->
      ensureInsertLastInserted = (key, options) ->
        {insert, text, finalText} = options
        ensure key
        editor.insertText(insert)
        ensure "escape", text: text
        ensure "G I ctrl-a", text: finalText

      beforeEach ->
        atom.keymaps.add "test",
          'atom-text-editor.vim-mode-plus.insert-mode':
            'ctrl-a': 'vim-mode-plus:insert-last-inserted'

        initialText = """
          abc
          def\n
          """
        set text: "", cursor: [0, 0]
        ensure 'i'

Response:
editor.insertText(initialText)
        ensure "escape g g",
          text: initialText
          cursor: [0, 0]

      it "case-i: single-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx'
          text: "xxxabc\ndef\n"
          finalText: "xxxabc\nxxxdef\n"
      it "case-o: single-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx'
          text: "abc\nxxx\ndef\n"
          finalText: "abc\nxxx\nxxxdef\n"
      it "case-O: single-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx'
          text: "xxx\nabc\ndef\n"
          finalText: "xxx\nabc\nxxxdef\n"


Response:
it "case-i: multi-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\nabc\ndef\n"
          finalText: "xxx\nyyy\nabc\nxxx\nyyy\ndef\n"
      it "case-o: multi-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx\nyyy\n'
          text: "abc\nxxx\nyyy\n\ndef\n"
          finalText: "abc\nxxx\nyyy\n\nxxx\nyyy\ndef\n"
      it "case-O: multi-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\n\nabc\ndef\n"
          finalText: "xxx\nyyy\n\nabc\nxxx\nyyy\ndef\n"


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
it "case-i: multi-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\nabc\ndef\n"
          finalText: "xxx\nyyy\nabc\nxxx\nyyy\ndef\n"
      it "case-o: multi-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx\nyyy\n'
          text: "abc\nxxx\nyyy\n\ndef\n"
          finalText: "abc\nxxx\nyyy\n\nxxx\nyyy\ndef\n"
      it "case-O: multi-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\n\nabc\ndef\n"
          finalText: "xxx\nyyy\n\nabc\nxxx\nyyy\ndef\n"
```

Response:
it("case-i: multi-line", function() {
  return ensureInsertLastInserted('i', {
    insert: 'xxx\nyyy\n',
    text: "xxx\nyyy\nabc\ndef\n",
    finalText: "xxx\nyyy\nabc\nxxx\nyyy\ndef\n"
  });
});

it("case-o: multi-line", function() {
  return ensureInsertLastInserted('o', {
    insert: 'xxx\nyyy\n',
    text: "abc\nxxx\nyyy\n\ndef\n",
    finalText: "abc\nxxx\nyyy\n\nxxx\nyyy\ndef\n"
  });
});

it("case-O: multi-line", function() {
  return ensureInsertLastInserted('O', {
    insert: 'xxx\nyyy\n',
    text: "xxx\nyyy\n\nabc\ndef\n",
    finalText: "xxx\nyyy\n\nabc\nxxx\nyyy\ndef\n"
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
it("case-i: multi-line", function() {
  return ensureInsertLastInserted('i', {
    insert: 'xxx\nyyy\n',
    text: "xxx\nyyy\nabc\ndef\n",
    finalText: "xxx\nyyy\nabc\nxxx\nyyy\ndef\n"
  });
});

it("case-o: multi-line", function() {
  return ensureInsertLastInserted('o', {
    insert: 'xxx\nyyy\n',
    text: "abc\nxxx\nyyy\n\ndef\n",
    finalText: "abc\nxxx\nyyy\n\nxxx\nyyy\ndef\n"
  });
});

it("case-O: multi-line", function() {
  return ensureInsertLastInserted('O', {
    insert: 'xxx\nyyy\n',
    text: "xxx\nyyy\n\nabc\ndef\n",
    finalText: "xxx\nyyy\n\nabc\nxxx\nyyy\ndef\n"
  });
});
```

Response:
it "case-i: multi-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\nabc\ndef\n"
          finalText: "xxx\nyyy\nabc\nxxx\nyyy\ndef\n"
      it "case-o: multi-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx\nyyy\n'
          text: "abc\nxxx\nyyy\n\ndef\n"
          finalText: "abc\nxxx\nyyy\n\nxxx\nyyy\ndef\n"
      it "case-O: multi-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\n\nabc\ndef\n"
          finalText: "xxx\nyyy\n\nabc\nxxx\nyyy\ndef\n"


Prompt:
it "case-i: multi-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\nabc\ndef\n"
          finalText: "xxx\nyyy\nabc\nxxx\nyyy\ndef\n"
      it "case-o: multi-line", ->
        ensureInsertLastInserted 'o',

Response:
insert: 'xxx\nyyy\n'
          text: "abc\nxxx\nyyy\n\ndef\n"
          finalText: "abc\nxxx\nyyy\n\nxxx\nyyy\ndef\n"
      it "case-O: multi-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx\nyyy\n'
          text: "xxx\nyyy\n\nabc\ndef\n"
          finalText: "xxx\nyyy\n\nabc\nxxx\nyyy\ndef\n"


Response:
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """
        cursor: [[1, 0], [3, 0]]
      ensure 'i', {}

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """
        cursor: [[1, 0], [3, 0]]
      ensure 'i', {}

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """
```

Response:
var getVimState;

({getVimState} = require('./spec-helper'));

describe("Insert mode commands", function() {
  var editor, editorElement, ensure, set, vimState;
  [set, ensure, editor, editorElement, vimState] = [];
  beforeEach(function() {
    return getVimState(function(_vimState, vim) {
      vimState = _vimState;
      ({editor, editorElement} = _vimState);
      return ({set, ensure} = vim);
    });
  });
  return describe("Copy from line above/below", function() {
    beforeEach(function() {
      set({
        text: `12345

abcd
efghi`,
        cursor: [[1, 0], [3, 0]]
      });
      return ensure('i', {});
    });
    return describe("the ctrl-y command", function() {
      return it("copies from the line above", function() {
        ensure('ctrl-y', {
          text: `12345
1
abcd
aefghi`
        });
        editor.insertText(' ');
        return ensure('ctrl-y', {
          text: `12345
1 3
abcd
a cefghi`
        });
      });
    });
  });
});


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

({getVimState} = require('./spec-helper'));

describe("Insert mode commands", function() {
  var editor, editorElement, ensure, set, vimState;
  [set, ensure, editor, editorElement, vimState] = [];
  beforeEach(function() {
    return getVimState(function(_vimState, vim) {
      vimState = _vimState;
      ({editor, editorElement} = _vimState);
      return ({set, ensure} = vim);
    });
  });
  return describe("Copy from line above/below", function() {
    beforeEach(function() {
      set({
        text: `12345

abcd
efghi`,
        cursor: [[1, 0], [3, 0]]
      });
      return ensure('i', {});
    });
    return describe("the ctrl-y command", function() {
      return it("copies from the line above", function() {
        ensure('ctrl-y', {
          text: `12345
1
abcd
aefghi`
        });
        editor.insertText(' ');
        return ensure('ctrl-y', {
          text: `12345
1 3
abcd
a cefghi`
        });
      });
    });
  });
});
```

Response:
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """
        cursor: [[1, 0], [3, 0]]
      ensure 'i', {}

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """


Prompt:
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """

Response:
cursor: [[1, 0], [3, 0]]
      ensure 'i', {}

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """


Response:
it "does nothing if there's nothing above the cursor", ->
        editor.insertText 'fill'
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """

      it "does nothing on the first line", ->
        set
          textC: """
          12|345

          abcd
          ef!ghi
          """

        editor.insertText 'a'
        ensure
          textC: """
            12a|345

            abcd
            efa!ghi
            """
        ensure 'ctrl-y',
          textC: """
            12a|345

            abcd
            efad!ghi
            """


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
it "does nothing if there's nothing above the cursor", ->
        editor.insertText 'fill'
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """

      it "does nothing on the first line", ->
        set
          textC: """
          12|345

          abcd
          ef!ghi
          """

        editor.insertText 'a'
        ensure
          textC: """
            12a|345

            abcd
            efa!ghi
            """
        ensure 'ctrl-y',
          textC: """
            12a|345

            abcd
            efad!ghi
            """
```

Response:
it("does nothing if there's nothing above the cursor", function() {
  editor.insertText('fill');
  ensure('ctrl-y', {
    text: `12345
fill5
abcd
fillefghi`
  });
  return ensure('ctrl-y', {
    text: `12345
fill5
abcd
fillefghi`
  });
});

it("does nothing on the first line", function() {
  set({
    textC: `12|345

abcd
ef!ghi`
  });
  editor.insertText('a');
  ensure({
    textC: `12a|345

abcd
efa!ghi`
  });
  return ensure('ctrl-y', {
    textC: `12a|345

abcd
efad!ghi`
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
it("does nothing if there's nothing above the cursor", function() {
  editor.insertText('fill');
  ensure('ctrl-y', {
    text: `12345
fill5
abcd
fillefghi`
  });
  return ensure('ctrl-y', {
    text: `12345
fill5
abcd
fillefghi`
  });
});

it("does nothing on the first line", function() {
  set({
    textC: `12|345

abcd
ef!ghi`
  });
  editor.insertText('a');
  ensure({
    textC: `12a|345

abcd
efa!ghi`
  });
  return ensure('ctrl-y', {
    textC: `12a|345

abcd
efad!ghi`
  });
});
```

Response:
it "does nothing if there's nothing above the cursor", ->
        editor.insertText 'fill'
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """

      it "does nothing on the first line", ->
        set
          textC: """
          12|345

          abcd
          ef!ghi
          """

        editor.insertText 'a'
        ensure
          textC: """
            12a|345

            abcd
            efa!ghi
            """
        ensure 'ctrl-y',
          textC: """
            12a|345

            abcd
            efad!ghi
            """


Prompt:
it "does nothing if there's nothing above the cursor", ->
        editor.insertText 'fill'
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """
        ensure 'ctrl-y',
          text: """
            12345
            fill5
            abcd
            fillefghi
            """

      it "does nothing on the first line", ->
        set
          textC: """

Response:
12|345

          abcd
          ef!ghi
          """

        editor.insertText 'a'
        ensure
          textC: """
            12a|345

            abcd
            efa!ghi
            """
        ensure 'ctrl-y',
          textC: """
            12a|345

            abcd
            efad!ghi
            """


Response:
describe "InsertLastInserted", ->
      ensureInsertLastInserted = (key, options) ->
        {insert, text, finalText} = options
        ensure key, {}
        editor.insertText(insert)
        ensure "escape", text: text
        ensure "G I ctrl-a", text: finalText

      beforeEach ->
        atom.keymaps.add "test",
          'atom-text-editor.vim-mode-plus.insert-mode':
            'ctrl-a': 'vim-mode-plus:insert-last-inserted'

        initialText = """
          abc
          def\n
          """
        set text: "", cursor: [0, 0]
        ensure 'i', {}
        editor.insertText(initialText)
        ensure "escape g g",
          text: initialText
          cursor: [0, 0]

      it "case-i: single-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx'
          text: "xxxabc\ndef\n"
          finalText: "xxxabc\nxxxdef\n"
      it "case-o: single-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx'
          text: "abc\nxxx\ndef\n"
          finalText: "abc\nxxx\nxxxdef\n"
      it "case-O: single-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx'
          text: "xxx\nabc\ndef\n"
          finalText: "xxx\nabc\nxxxdef\n"


Prompt:
describe "InsertLastInserted", ->
      ensureInsertLastInserted = (key, options) ->
        {insert, text, finalText} = options
        ensure key, {}
        editor.insertText(insert)
        ensure "escape", text: text
        ensure "G I ctrl-a", text: finalText

      beforeEach ->
        atom.keymaps.add "test",
          'atom-text-editor.vim-mode-plus.insert-mode':
            'ctrl-a': 'vim-mode-plus:insert-last-inserted'

        initialText = """
          abc
          def\n
          """
        set text: "", cursor: [0, 0]
        ensure 'i', {}

Response:
editor.insertText(initialText)
        ensure "escape g g",
          text: initialText
          cursor: [0, 0]

      it "case-i: single-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx'
          text: "xxxabc\ndef\n"
          finalText: "xxxabc\nxxxdef\n"
      it "case-o: single-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx'
          text: "abc\nxxx\ndef\n"
          finalText: "abc\nxxx\nxxxdef\n"
      it "case-O: single-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx'
          text: "xxx\nabc\ndef\n"
          finalText: "xxx\nabc\nxxxdef\n"


Response:
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, keystroke, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure, keystroke} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """
        cursor: [[1, 0], [3, 0]]
      keystroke 'i'

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, keystroke, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure, keystroke} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """
        cursor: [[1, 0], [3, 0]]
      keystroke 'i'

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """
```

Response:
var getVimState;

({getVimState} = require('./spec-helper'));

describe("Insert mode commands", function() {
  var editor, editorElement, ensure, keystroke, set, vimState;
  [set, ensure, keystroke, editor, editorElement, vimState] = [];
  beforeEach(function() {
    return getVimState(function(_vimState, vim) {
      vimState = _vimState;
      ({editor, editorElement} = _vimState);
      return ({set, ensure, keystroke} = vim);
    });
  });
  return describe("Copy from line above/below", function() {
    beforeEach(function() {
      set({
        text: `12345

abcd
efghi`,
        cursor: [[1, 0], [3, 0]]
      });
      return keystroke('i');
    });
    return describe("the ctrl-y command", function() {
      return it("copies from the line above", function() {
        ensure('ctrl-y', {
          text: `12345
1
abcd
aefghi`
        });
        editor.insertText(' ');
        return ensure('ctrl-y', {
          text: `12345
1 3
abcd
a cefghi`
        });
      });
    });
  });
});


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

({getVimState} = require('./spec-helper'));

describe("Insert mode commands", function() {
  var editor, editorElement, ensure, keystroke, set, vimState;
  [set, ensure, keystroke, editor, editorElement, vimState] = [];
  beforeEach(function() {
    return getVimState(function(_vimState, vim) {
      vimState = _vimState;
      ({editor, editorElement} = _vimState);
      return ({set, ensure, keystroke} = vim);
    });
  });
  return describe("Copy from line above/below", function() {
    beforeEach(function() {
      set({
        text: `12345

abcd
efghi`,
        cursor: [[1, 0], [3, 0]]
      });
      return keystroke('i');
    });
    return describe("the ctrl-y command", function() {
      return it("copies from the line above", function() {
        ensure('ctrl-y', {
          text: `12345
1
abcd
aefghi`
        });
        editor.insertText(' ');
        return ensure('ctrl-y', {
          text: `12345
1 3
abcd
a cefghi`
        });
      });
    });
  });
});
```

Response:
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, keystroke, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure, keystroke} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """
        cursor: [[1, 0], [3, 0]]
      keystroke 'i'

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """


Prompt:
{getVimState} = require './spec-helper'

describe "Insert mode commands", ->
  [set, ensure, keystroke, editor, editorElement, vimState] = []

  beforeEach ->
    getVimState (_vimState, vim) ->
      vimState = _vimState
      {editor, editorElement} = _vimState
      {set, ensure, keystroke} = vim

  describe "Copy from line above/below", ->
    beforeEach ->
      set
        text: """
          12345

          abcd
          efghi
          """

Response:
cursor: [[1, 0], [3, 0]]
      keystroke 'i'

    describe "the ctrl-y command", ->
      it "copies from the line above", ->
        ensure 'ctrl-y',
          text: """
            12345
            1
            abcd
            aefghi
            """
        editor.insertText ' '
        ensure 'ctrl-y',
          text: """
            12345
            1 3
            abcd
            a cefghi
            """


Response:
describe "InsertLastInserted", ->
      ensureInsertLastInserted = (key, options) ->
        {insert, text, finalText} = options
        keystroke key
        editor.insertText(insert)
        ensure "escape", text: text
        ensure "G I ctrl-a", text: finalText

      beforeEach ->
        atom.keymaps.add "test",
          'atom-text-editor.vim-mode-plus.insert-mode':
            'ctrl-a': 'vim-mode-plus:insert-last-inserted'

        initialText = """
          abc
          def\n
          """
        set text: "", cursor: [0, 0]
        keystroke 'i'
        editor.insertText(initialText)
        ensure "escape g g",
          text: initialText
          cursor: [0, 0]

      it "case-i: single-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx'
          text: "xxxabc\ndef\n"
          finalText: "xxxabc\nxxxdef\n"
      it "case-o: single-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx'
          text: "abc\nxxx\ndef\n"
          finalText: "abc\nxxx\nxxxdef\n"
      it "case-O: single-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx'
          text: "xxx\nabc\ndef\n"
          finalText: "xxx\nabc\nxxxdef\n"


Prompt:
describe "InsertLastInserted", ->
      ensureInsertLastInserted = (key, options) ->
        {insert, text, finalText} = options
        keystroke key
        editor.insertText(insert)
        ensure "escape", text: text
        ensure "G I ctrl-a", text: finalText

      beforeEach ->
        atom.keymaps.add "test",
          'atom-text-editor.vim-mode-plus.insert-mode':
            'ctrl-a': 'vim-mode-plus:insert-last-inserted'

        initialText = """
          abc
          def\n
          """
        set text: "", cursor: [0, 0]
        keystroke 'i'

Response:
editor.insertText(initialText)
        ensure "escape g g",
          text: initialText
          cursor: [0, 0]

      it "case-i: single-line", ->
        ensureInsertLastInserted 'i',
          insert: 'xxx'
          text: "xxxabc\ndef\n"
          finalText: "xxxabc\nxxxdef\n"
      it "case-o: single-line", ->
        ensureInsertLastInserted 'o',
          insert: 'xxx'
          text: "abc\nxxx\ndef\n"
          finalText: "abc\nxxx\nxxxdef\n"
      it "case-O: single-line", ->
        ensureInsertLastInserted 'O',
          insert: 'xxx'
          text: "xxx\nabc\ndef\n"
          finalText: "xxx\nabc\nxxxdef\n"


Response:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix.Transformation1)
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix)

      expect(-> engine.output.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.output.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix.Transformation1)
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix)

      expect(-> engine.output.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.output.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated
```

Response:
var assert, expect;

expect = chai.expect;

assert = chai.assert;

describe('Matrix', function() {
  var engine;
  engine = null;
  before(function() {
    var container;
    container = document.createElement('div');
    engine = new GSS(container);
    return engine.compile();
  });
  describe('dispatched by argument types', function() {
    return it('should properly recognize matrix operations', function() {
      expect(engine.output.Command(['translateX', 3])).to.be.an.instanceof(engine.output.Matrix.Transformation1);
      expect(engine.output.Command(['translateX', 3])).to.be.an.instanceof(engine.output.Matrix);
      expect(function() {
        return engine.output.Command(['translateX', 3, 3]);
      }).to.throw(/Too many/);
      return expect(function() {
        return engine.output.Command(['translateX', 'a']);
      }).to.throw(/Unexpected argument/);
    });
  });
  return describe('when executed', function() {
    describe('independently', function() {
      return it('should initialize matrix', function() {
        var rotate, rotated;
        rotated = engine.output.Matrix.prototype._mat4.create();
        rotated = engine.output.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', 0.5];
        return expect(engine.output.Command(rotate).solve(engine.output, rotate)).to.eql(rotated);
      });
    });
    describe('as nested commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.output.Matrix.prototype._mat4.create();
        rotated = engine.output.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.output.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5];
        return expect(engine.output.Command(rotate).solve(engine.output, rotate)).to.eql(rotated);
      });
    });
    return describe('as flat commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.output.Matrix.prototype._mat4.create();
        rotated = engine.output.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.output.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]];
        return expect(engine.output.Command(rotate).solve(engine.output, rotate)).to.eql(rotated);
      });
    });
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var assert, expect;

expect = chai.expect;

assert = chai.assert;

describe('Matrix', function() {
  var engine;
  engine = null;
  before(function() {
    var container;
    container = document.createElement('div');
    engine = new GSS(container);
    return engine.compile();
  });
  describe('dispatched by argument types', function() {
    return it('should properly recognize matrix operations', function() {
      expect(engine.output.Command(['translateX', 3])).to.be.an.instanceof(engine.output.Matrix.Transformation1);
      expect(engine.output.Command(['translateX', 3])).to.be.an.instanceof(engine.output.Matrix);
      expect(function() {
        return engine.output.Command(['translateX', 3, 3]);
      }).to.throw(/Too many/);
      return expect(function() {
        return engine.output.Command(['translateX', 'a']);
      }).to.throw(/Unexpected argument/);
    });
  });
  return describe('when executed', function() {
    describe('independently', function() {
      return it('should initialize matrix', function() {
        var rotate, rotated;
        rotated = engine.output.Matrix.prototype._mat4.create();
        rotated = engine.output.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', 0.5];
        return expect(engine.output.Command(rotate).solve(engine.output, rotate)).to.eql(rotated);
      });
    });
    describe('as nested commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.output.Matrix.prototype._mat4.create();
        rotated = engine.output.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.output.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5];
        return expect(engine.output.Command(rotate).solve(engine.output, rotate)).to.eql(rotated);
      });
    });
    return describe('as flat commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.output.Matrix.prototype._mat4.create();
        rotated = engine.output.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.output.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]];
        return expect(engine.output.Command(rotate).solve(engine.output, rotate)).to.eql(rotated);
      });
    });
  });
});
```

Response:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix.Transformation1)
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix)

      expect(-> engine.output.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.output.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated


Prompt:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix.Transformation1)
      expect(engine.output.Command(['translateX', 3])).to.be.an.
        instanceof(engine.output.Matrix)

      expect(-> engine.output.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.output.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->

Response:
describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.output.Matrix::_mat4.create()
        rotated = engine.output.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.output.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.output.Command(rotate).solve(engine.output, rotate)).
          to.eql rotated


Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  xdescribe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  xdescribe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)
```

Response:
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.output.Command(sequence)).to.be.an.instanceof(engine.output.Matrix.prototype.Sequence);
    expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.output.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

xdescribe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.output.Command(sequence)).to.be.an.instanceof(engine.output.Matrix.prototype.Sequence);
    expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.output.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

xdescribe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});
```

Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  xdescribe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->

Response:
engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  xdescribe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)
```

Response:
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.output.Command(sequence)).to.be.an.instanceof(engine.output.Matrix.prototype.Sequence);
    expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.output.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.output.Command(sequence)).to.be.an.instanceof(engine.output.Matrix.prototype.Sequence);
    expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.output.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});
```

Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.output.Command(sequence)).to.be.an.
        instanceof(engine.output.Matrix::Sequence)
      expect(engine.output.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.output.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.output.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->

Response:
engine.output.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Response:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix.Transformation1)
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix)

      expect(-> engine.data.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.data.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix.Transformation1)
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix)

      expect(-> engine.data.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.data.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated
```

Response:
var assert, expect;

expect = chai.expect;

assert = chai.assert;

describe('Matrix', function() {
  var engine;
  engine = null;
  before(function() {
    var container;
    container = document.createElement('div');
    engine = new GSS(container);
    return engine.compile();
  });
  describe('dispatched by argument types', function() {
    return it('should properly recognize matrix operations', function() {
      expect(engine.data.Command(['translateX', 3])).to.be.an.instanceof(engine.data.Matrix.Transformation1);
      expect(engine.data.Command(['translateX', 3])).to.be.an.instanceof(engine.data.Matrix);
      expect(function() {
        return engine.data.Command(['translateX', 3, 3]);
      }).to.throw(/Too many/);
      return expect(function() {
        return engine.data.Command(['translateX', 'a']);
      }).to.throw(/Unexpected argument/);
    });
  });
  return describe('when executed', function() {
    describe('independently', function() {
      return it('should initialize matrix', function() {
        var rotate, rotated;
        rotated = engine.data.Matrix.prototype._mat4.create();
        rotated = engine.data.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', 0.5];
        return expect(engine.data.Command(rotate).solve(engine.data, rotate)).to.eql(rotated);
      });
    });
    describe('as nested commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.data.Matrix.prototype._mat4.create();
        rotated = engine.data.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.data.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5];
        return expect(engine.data.Command(rotate).solve(engine.data, rotate)).to.eql(rotated);
      });
    });
    return describe('as flat commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.data.Matrix.prototype._mat4.create();
        rotated = engine.data.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.data.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]];
        return expect(engine.data.Command(rotate).solve(engine.data, rotate)).to.eql(rotated);
      });
    });
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var assert, expect;

expect = chai.expect;

assert = chai.assert;

describe('Matrix', function() {
  var engine;
  engine = null;
  before(function() {
    var container;
    container = document.createElement('div');
    engine = new GSS(container);
    return engine.compile();
  });
  describe('dispatched by argument types', function() {
    return it('should properly recognize matrix operations', function() {
      expect(engine.data.Command(['translateX', 3])).to.be.an.instanceof(engine.data.Matrix.Transformation1);
      expect(engine.data.Command(['translateX', 3])).to.be.an.instanceof(engine.data.Matrix);
      expect(function() {
        return engine.data.Command(['translateX', 3, 3]);
      }).to.throw(/Too many/);
      return expect(function() {
        return engine.data.Command(['translateX', 'a']);
      }).to.throw(/Unexpected argument/);
    });
  });
  return describe('when executed', function() {
    describe('independently', function() {
      return it('should initialize matrix', function() {
        var rotate, rotated;
        rotated = engine.data.Matrix.prototype._mat4.create();
        rotated = engine.data.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', 0.5];
        return expect(engine.data.Command(rotate).solve(engine.data, rotate)).to.eql(rotated);
      });
    });
    describe('as nested commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.data.Matrix.prototype._mat4.create();
        rotated = engine.data.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.data.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5];
        return expect(engine.data.Command(rotate).solve(engine.data, rotate)).to.eql(rotated);
      });
    });
    return describe('as flat commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.data.Matrix.prototype._mat4.create();
        rotated = engine.data.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.data.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]];
        return expect(engine.data.Command(rotate).solve(engine.data, rotate)).to.eql(rotated);
      });
    });
  });
});
```

Response:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix.Transformation1)
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix)

      expect(-> engine.data.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.data.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated


Prompt:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix.Transformation1)
      expect(engine.data.Command(['translateX', 3])).to.be.an.
        instanceof(engine.data.Matrix)

      expect(-> engine.data.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.data.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->

Response:
describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.data.Matrix::_mat4.create()
        rotated = engine.data.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.data.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.data.Command(rotate).solve(engine.data, rotate)).
          to.eql rotated


Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.data.Command(sequence)).to.be.an.
        instanceof(engine.data.Matrix::Sequence)
      expect(engine.data.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.data.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.data.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.data.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.data.Command(sequence)).to.be.an.
        instanceof(engine.data.Matrix::Sequence)
      expect(engine.data.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.data.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.data.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.data.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)
```

Response:
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.data.Command(sequence)).to.be.an.instanceof(engine.data.Matrix.prototype.Sequence);
    expect(engine.data.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.data.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.data.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.data.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.data.Command(sequence)).to.be.an.instanceof(engine.data.Matrix.prototype.Sequence);
    expect(engine.data.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.data.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.data.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.data.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});
```

Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.data.Command(sequence)).to.be.an.
        instanceof(engine.data.Matrix::Sequence)
      expect(engine.data.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.data.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.data.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.data.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.data.Command(sequence)).to.be.an.
        instanceof(engine.data.Matrix::Sequence)
      expect(engine.data.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.data.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.data.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->

Response:
engine.data.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Response:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix.Transformation1)
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix)

      expect(-> engine.intrinsic.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.intrinsic.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix.Transformation1)
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix)

      expect(-> engine.intrinsic.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.intrinsic.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated
```

Response:
var assert, expect;

expect = chai.expect;

assert = chai.assert;

describe('Matrix', function() {
  var engine;
  engine = null;
  before(function() {
    var container;
    container = document.createElement('div');
    engine = new GSS(container);
    return engine.compile();
  });
  describe('dispatched by argument types', function() {
    return it('should properly recognize matrix operations', function() {
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.instanceof(engine.intrinsic.Matrix.Transformation1);
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.instanceof(engine.intrinsic.Matrix);
      expect(function() {
        return engine.intrinsic.Command(['translateX', 3, 3]);
      }).to.throw(/Too many/);
      return expect(function() {
        return engine.intrinsic.Command(['translateX', 'a']);
      }).to.throw(/Unexpected argument/);
    });
  });
  return describe('when executed', function() {
    describe('independently', function() {
      return it('should initialize matrix', function() {
        var rotate, rotated;
        rotated = engine.intrinsic.Matrix.prototype._mat4.create();
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', 0.5];
        return expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).to.eql(rotated);
      });
    });
    describe('as nested commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.intrinsic.Matrix.prototype._mat4.create();
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5];
        return expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).to.eql(rotated);
      });
    });
    return describe('as flat commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.intrinsic.Matrix.prototype._mat4.create();
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]];
        return expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).to.eql(rotated);
      });
    });
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
var assert, expect;

expect = chai.expect;

assert = chai.assert;

describe('Matrix', function() {
  var engine;
  engine = null;
  before(function() {
    var container;
    container = document.createElement('div');
    engine = new GSS(container);
    return engine.compile();
  });
  describe('dispatched by argument types', function() {
    return it('should properly recognize matrix operations', function() {
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.instanceof(engine.intrinsic.Matrix.Transformation1);
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.instanceof(engine.intrinsic.Matrix);
      expect(function() {
        return engine.intrinsic.Command(['translateX', 3, 3]);
      }).to.throw(/Too many/);
      return expect(function() {
        return engine.intrinsic.Command(['translateX', 'a']);
      }).to.throw(/Unexpected argument/);
    });
  });
  return describe('when executed', function() {
    describe('independently', function() {
      return it('should initialize matrix', function() {
        var rotate, rotated;
        rotated = engine.intrinsic.Matrix.prototype._mat4.create();
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', 0.5];
        return expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).to.eql(rotated);
      });
    });
    describe('as nested commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.intrinsic.Matrix.prototype._mat4.create();
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5];
        return expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).to.eql(rotated);
      });
    });
    return describe('as flat commands', function() {
      return it('should return final matrix', function() {
        var rotate, rotated;
        rotated = engine.intrinsic.Matrix.prototype._mat4.create();
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateY(rotated, rotated, -18 * (Math.PI / 180));
        rotated = engine.intrinsic.Matrix.prototype._mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180));
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]];
        return expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).to.eql(rotated);
      });
    });
  });
});
```

Response:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix.Transformation1)
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix)

      expect(-> engine.intrinsic.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.intrinsic.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->
    describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated


Prompt:
expect = chai.expect
assert = chai.assert

describe 'Matrix', ->
  engine = null
  before ->
    container = document.createElement('div')
    engine = new GSS(container)
    engine.compile()

  describe 'dispatched by argument types', ->
    it 'should properly recognize matrix operations', ->
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix.Transformation1)
      expect(engine.intrinsic.Command(['translateX', 3])).to.be.an.
        instanceof(engine.intrinsic.Matrix)

      expect(-> engine.intrinsic.Command(['translateX', 3, 3])).to.
        throw(/Too many/)

      expect(-> engine.intrinsic.Command(['translateX', 'a'])).to.
        throw(/Unexpected argument/)

  describe 'when executed', ->

Response:
describe 'independently', ->
      it 'should initialize matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as nested commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = ['rotateZ', ['rotateY', -0.05], 0.5]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated

    describe 'as flat commands', ->
      it 'should return final matrix', ->
        rotated = engine.intrinsic.Matrix::_mat4.create()
        rotated = engine.intrinsic.Matrix::_mat4.rotateY(rotated, rotated, - 18 * (Math.PI / 180))
        rotated = engine.intrinsic.Matrix::_mat4.rotateZ(rotated, rotated, 180 * (Math.PI / 180))
        rotate = [['rotateY', -0.05], ['rotateZ', 0.5]]
        expect(engine.intrinsic.Command(rotate).solve(engine.intrinsic, rotate)).
          to.eql rotated


Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)
```

Response:
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.intrinsic.Command(sequence)).to.be.an.instanceof(engine.intrinsic.Matrix.prototype.Sequence);
    expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.intrinsic.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.intrinsic.Command(sequence)).to.be.an.instanceof(engine.intrinsic.Matrix.prototype.Sequence);
    expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.intrinsic.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});
```

Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->

Response:
engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)
```

Response:
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.intrinsic.Command(sequence)).to.be.an.instanceof(engine.intrinsic.Matrix.prototype.Sequence);
    expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.intrinsic.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});


Prompt:
Convert this JavaScript to CoffeeScript.
```javascript
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.intrinsic.Command(sequence)).to.be.an.instanceof(engine.intrinsic.Matrix.prototype.Sequence);
    expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.intrinsic.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
  });
});
```

Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Prompt:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)

Response:
expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      expect(engine.solve([
        ['translateX', 3]
        ['rotateZ', ['get', 'a']]
      ])).to.eql(1)


Response:
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      setTimeout ->
        expect(engine.solve([
            #['set', 'transform', [
              ['translateX', 3]
              ['rotateZ', ['get', 'a']]
            #]]
        ])).to.eql(1)
      , 1


Prompt:
Convert this CoffeeScript to JavaScript.
```coffeescript
describe 'defined as a sequence of matrix operations', ->
    it 'should group together', ->
      sequence = [
        ['translateX', 3],
        ['rotateZ', 2]
      ]
      expect(engine.intrinsic.Command(sequence)).to.be.an.
        instanceof(engine.intrinsic.Matrix::Sequence)
      expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command)
      expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command)
      expect(->
        engine.intrinsic.Command([
          1,
          ['rotateZ', 2]
        ])
      ).to.throw(/Undefined/)

  describe 'when used with variables', ->
    it 'should update and recompute matrix', (done) ->
      setTimeout ->
        expect(engine.solve([
            #['set', 'transform', [
              ['translateX', 3]
              ['rotateZ', ['get', 'a']]
            #]]
        ])).to.eql(1)
      , 1
```

Response:
describe('defined as a sequence of matrix operations', function() {
  return it('should group together', function() {
    var sequence;
    sequence = [['translateX', 3], ['rotateZ', 2]];
    expect(engine.intrinsic.Command(sequence)).to.be.an.instanceof(engine.intrinsic.Matrix.prototype.Sequence);
    expect(engine.intrinsic.Command(['translateX', 3])).to.eql(sequence[0].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', 3])).to.not.eql(sequence[1].command);
    expect(engine.intrinsic.Command(['rotateZ', ['translateX', 3], 3])).to.eql(sequence[1].command);
    return expect(function() {
      return engine.intrinsic.Command([1, ['rotateZ', 2]]);
    }).to.throw(/Undefined/);
  });
});

describe('when used with variables', function() {
  return it('should update and recompute matrix', function(done) {
    return setTimeout(function() {
      //['set', 'transform', [
      //]]
      return expect(engine.solve([['translateX', 3], ['rotateZ', ['get', 'a']]])).to.eql(1);
    }, 1);
  });
});