jspsych 6.2.0 → 7.1.0

package/docs/overview/timeline.md

@@ -1,387 +0,0 @@
-# Creating an Experiment: The Timeline
-
-To create an experiment using jsPsych, you need to specify a timeline that describes the structure of the experiment. The timeline is an ordered set of trials. You must create the timeline before launching the experiment. Most of the code you will write for an experiment will be code to create the timeline. This page walks through the creation of timelines, including very basic examples and more advanced features.
-
-## A single trial
-
-To create a trial, you need to create an object that describes the trial. The most important feature of this object is the `type` parameter. This tells jsPsych which plugin file to use to run the trial. For example, if you want to use the text plugin to display a short message, the trial object would look like this:
-
-```javascript
-var trial = {
-	type: 'html-keyboard-response',
-	stimulus: 'hello world!'
-}
-```
-
-The parameters for this object will depend on the plugin that you choose. Each plugin defines the set of parameters that are needed to run a trial with that plugin. Visit the documentation for a plugin to learn about the parameters that you can use with that plugin.
-
-To create a timeline with the single trial and run the experiment, just embed the trial object in an array. A timeline is simply an array of trials.
-
-```javascript
-var timeline = [trial];
-
-jsPsych.init({
-	timeline: timeline
-});
-```
-
-To actually create and run this simple example, complete the [hello world tutorial](../tutorials/hello-world.md).
-
-## Multiple trials
-
-Scaling up to multiple trials is straightforward. Just create an object for each trial, and add each object to the timeline array.
-
-```javascript
-// with lots of trials, it might be easier to add the trials
-// to the timeline array as they are defined.
-var timeline = [];
-
-var trial_1 = {
-	type: 'html-keyboard-response',
-	stimulus: 'This is trial 1.'
-}
-timeline.push(trial_1);
-
-var trial_2 = {
-	type: 'html-keyboard-response',
-	stimulus: 'This is trial 2.'
-}
-timeline.push(trial_2);
-
-var trial_3 = {
-	type: 'html-keyboard-response',
-	stimulus: 'This is trial 3.'
-}
-timeline.push(trial_3);
-```
-
-## Nested timelines
-
-Each object on the timeline can also have it's own timeline. This is useful for many reasons. One is that it allows you to define common parameters across trials once and have them apply to all the trials on the nested timeline. The example below creates a series of trials using the image-keyboard-response plugin, where the only thing that changes from trial-to-trial is the image file being displayed on the screen.
-
-```javascript
-var judgment_trials = {
-	type: 'image-keyboard-response',
-	prompt: '<p>Press a number 1-7 to indicate how unusual the image is.</p>',
-	choices: ['1','2','3','4','5','6','7'],
-	timeline: [
-		{stimulus: 'image1.png'},
-		{stimulus: 'image2.png'},
-		{stimulus: 'image3.png'}
-	]
-}
-```
-
-In the above code, the `type`, `prompt`, and `choices` parameters are automatically applied to all of the objects in the `timeline` array. This creates three trials with the same `type`, `prompt`, and `choices` parameters, but different values for the `stimulus` parameter.
-
-You can also override the values by declaring a new value in the `timeline` array. In the example below, the second trial will display a different prompt message.
-
-```javascript
-var judgment_trials = {
-	type: 'image-keyboard-response',
-	prompt: '<p>Press a number 1-7 to indicate how unusual the image is.</p>',
-	choices: ['1','2','3','4','5','6','7'],
-	timeline: [
-		{stimulus: 'image1.png'},
-		{stimulus: 'image2.png', prompt: '<p>Press 1 for this trial.</p>'},
-		{stimulus: 'image3.png'}
-	]
-}
-```
-
-Timelines can be nested any number of times.
-
-## Timeline variables
-
-A common pattern in behavioral experiments is to repeat the same procedure many times with slightly different parameters. A procedure might be a single trial, but it also might be a series of trials. One shortcut to implement this pattern is with the approach described in the previous section, but this only works if all the trials use the same plugin type. Timeline variables are a more general solution. With timeline variables you define the procedure once (as a timeline) and specify a set of parameters and their values for each iteration through the timeline.
-
-What follows is an example of how to use timeline variables. The [simple reaction time tutorial](../tutorials/rt-task.md) also explains how to use timeline variables.
-
-Suppose we want to create an experiment where people see a set of faces. Perhaps this is a memory experiment and this is the phase of the experiment where the faces are being presented for the first time. In between each face, a fixation cross is displayed on the screen. Without timeline variables, we would need to add many trials to the timeline, alternating between trials showing the fixation cross and trials showing the face and name. This could be done efficiently using a loop or function, but timeline variables make it even easier - as well as adding extra features like sampling and randomization.
-
-Here's a basic version of the task with timeline variables.
-
-```javascript
-var face_name_procedure = {
-	timeline: [
-		{
-			type: 'html-keyboard-response',
-			stimulus: '+',
-			choices: jsPsych.NO_KEYS,
-			trial_duration: 500
-		},
-		{
-			type: 'image-keyboard-response',
-			stimulus: jsPsych.timelineVariable('face'),
-			choices: jsPsych.NO_KEYS,
-			trial_duration: 2500
-		}
-	],
-	timeline_variables: [
-		{ face: 'person-1.jpg' },
-		{ face: 'person-2.jpg' },
-		{ face: 'person-3.jpg' },
-		{ face: 'person-4.jpg' }
-	]
-}
-```
-
-In the above version, there are four separate trials defined in the `timeline_variables` parameter. Each trial has a variable `face` and a variable `name`. The `timeline` defines a procedure of showing a fixation cross for 500ms followed by the face and name for 2500ms.  This procedure will repeat four times, with the first trial showing Alex, the second Beth, and so on. The variables are referenced within the procedure by calling the `jsPsych.timelineVariable()` method and passing in the name of the variable.
-
-What if we wanted the stimuli to be a little more complex, with a name displayed below each face? And let's add an additional step where the name is displayed prior to the face appearing. (Maybe this is one condition of an experiment investigating whether the order of name-face or face-name affects retention.)
-
-To do this, we will need to use the `jsPsych.timelineVariable()` method in a slightly different way. Instead of using it as the parameter, we are going to create a dynamic parameter using a function and place the call to `jsPsych.timelineVariable()` inside this function. This will allow us to create an HTML string that has both the image and the name. Note that there is a subtle syntax difference: there is an extra parameter when `jsPsych.timelineVariable()` is called within a function. This `true` value causes the `jsPsych.timelineVariable()` to immediately return the value of the timeline variable. In a normal context, the function `jsPsych.timelineVariable()` returns a function. This is why `jsPsych.timelineVariable()` can be used directly as a parameter even though the parameter is dynamic.
-
-
-```javascript
-var face_name_procedure = {
-	timeline: [
-		{
-			type: 'html-keyboard-response',
-			stimulus: '+',
-			choices: jsPsych.NO_KEYS,
-			trial_duration: 500
-		},
-		{
-			type: 'html-keyboard-response',
-			stimulus: jsPsych.timelineVariable('name'),
-			trial_duration: 1000,
-			choices: jsPsych.NO_KEYS
-		},
-		{
-			type: 'html-keyboard-response',
-			stimulus: function(){
-				var html="<img src='"+jsPsych.timelineVariable('face', true)+"'>";
-				html += "<p>"+jsPsych.timelineVariable('name', true)+"</p>";
-				return html;
-			},			
-			choices: jsPsych.NO_KEYS,
-			trial_duration: 2500
-		}
-	],
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	]
-}
-```
-### Random orders of trials
-
-If we want to randomize the order of the trials, we can set `randomize_order` to `true`.
-
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	randomize_order: true
-}
-```
-
-### Repeating trials
-
-If we want to repeat the set of trials multiple times, then we can set `repetitions` to an integer. If `randomize_order` is also `true`, the order will re-randomize before every repetition.
-
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	randomize_order: true,
-	repetitions: 3
-}
-```
-
-### Sampling methods
-
-There are also a set of sampling methods that can be used to select a set of trials from the timeline_variables. Sampling is declared by creating a `sample` parameter. The `sample` parameter is given an object of arguments. The `type` parameter in this object controls the type of sampling that is done. Valid values for `type` are 
-
-* `"with-replacement"`: Sample `size` items from the timeline variables with the possibility of choosing the same item multiple time.
-* `"without-replacement"`: Sample `size` itesm from timeline variables, with each item being selected a maximum of 1 time.
-* `"fixed-repetitons"`: Repeat each item in the timeline variables `size` times, in a random order. Unlike using the `repetitons` parameter, this method allows for consecutive trials to use the same timeline variable set.
-* `"alternate-groups"`: Sample in an alternating order based on a declared group membership. Groups are defined by the `groups` parameter. This parameter takes an array of arrays, where each inner array is a group and the items in the inner array are the indices of the timeline variables in the `timeline_variables` array that belong to that group.
-* `"custom"`: Write a function that returns a custom order of the timeline variables.
-
-#### Sampling with replacement
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	sample: {
-		type: 'with-replacement',
-		size: 10, // 10 trials, with replacement
-	}
-}
-```
-
-#### Sampling with replacement, unequal probabilities
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	sample: {
-		type: 'with-replacement',
-		size: 10, // 10 trials, with replacement
-		weights: [3, 1, 1, 1], // The Alex trial is three times as likely to be sampled as the others.
-	}
-}
-```
-
-#### Sampling without replacement
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	sample: {
-		type: 'without-replacement',
-		size: 3, // 3 trials, without replacement
-	}
-}
-```
-
-#### Repeating each trial a fixed number of times in a random order
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	sample: {
-		type: 'fixed-repetitions',
-		size: 3, // 3 repetitions of each trial, 12 total trials, order is randomized.
-	}
-}
-```
-
-#### Alternating groups
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	sample: {
-		type: 'alternate-groups',
-		groups: [[0,2],[1,3]], // Alex and Chad are in group 1. Beth and Dave are in group 2. 
-		randomize_group_order: false // The first trial will be an item from group 1.
-	}
-}
-```
-
-#### Custom sampling function
-```javascript
-var face_name_procedure = {
-	// timeline parameter hidden to save space ...
-	timeline_variables: [
-		{ face: 'person-1.jpg', name: 'Alex' },
-		{ face: 'person-2.jpg', name: 'Beth' },
-		{ face: 'person-3.jpg', name: 'Chad' },
-		{ face: 'person-4.jpg', name: 'Dave' }
-	],
-	sample: {
-		type: 'custom',
-		fn: function(t){
-			// the first parameter to this function call is an array of integers
-			// from 0 to n-1, where n is the number of trials.
-			// the method needs to return an array of integers specifying the order
-			// that the trials should be executed. this array does not need to
-			// contain all of the integers.
-
-			return t.reverse(); // show the trials in the reverse order
-		}
-	}
-}
-```
-
-## Looping timelines
-
-Any timeline can be looped using the `loop_function` option. The loop function should be a function that evaluates to `true` if the timeline should repeat, and `false` if the timeline should end. It receives a single parameter: the DataCollection object with all of the data from the trials executed in the last iteration of the timeline. The loop function will be evaluated after the timeline is completed.
-
-```javascript
-var trial = {
-	type: 'html-keyboard-response',
-	stimulus: 'This trial is in a loop. Press R to repeat this trial, or C to continue.'
-}
-
-var loop_node = {
-	timeline: [trial],
-	loop_function: function(data){
-		if(jsPsych.pluginAPI.convertKeyCharacterToKeyCode('r') == data.values()[0].key_press){
-			return true;
-		} else {
-			return false;
-		}
-	}
-}
-```
-
-## Conditional timelines
-
-A timeline can be skipped based on the evaluation of a function using the `conditional_function` option. If the conditional function evaluates to `true`, the timeline will execute normally. If the conditional function evaluates to `false`, then the timeline will be skipped. The conditional function is evaluated whenever the timeline is about to run the first trial.
-
-```javascript
-var pre_if_trial = {
-	type: 'html-keyboard-response',
-	stimulus: 'The next trial is in a conditional statement. Press S to skip it, or V to view it.'
-}
-
-var if_trial = {
-	type: 'html-keyboard-response',
-	stimulus: 'You chose to view the trial. Press any key to continue.'
-}
-
-var if_node = {
-	timeline: [if_trial],
-	conditional_function: function(){
-		// get the data from the previous trial,
-		// and check which key was pressed
-		var data = jsPsych.data.get().last(1).values()[0];
-		if(data.key_press == jsPsych.pluginAPI.convertKeyCharacterToKeyCode('s')){
-			return false;
-		} else {
-			return true;
-		}
-	}
-}
-
-var after_if_trial = {
-	type: 'html-keyboard-response',
-	stimulus: 'This is the trial after the conditional.'
-}
-
-jsPsych.init({
-	timeline: [pre_if_trial, if_node, after_if_trial],
-	on_finish: function(){jsPsych.data.displayData(); }
-});
-```

package/docs/overview/trial.md

@@ -1,142 +0,0 @@
-# Advanced Options for Trials
-
-The parameters available for a trial depend primarily on what plugin is used for the trial. However, there are several options that do not depend on the particular plugin; they are available for all trials.
-
-## The data parameter
-
-The `data` parameter enables tagging the trial with additional properties. This can be useful for storing properties of the trial that are not directly apparent from the values that the plugin records. The `data` parameter value should be an object that contains key-value pairs.
-
-A simple example is the [Flanker Task](https://en.wikipedia.org/wiki/Eriksen_flanker_task). In this experiment, participants respond to the direction of an arrow, pressing a key to the left for a left-pointing arrow (<) and a key to the right for a right-pointing arrow (>). The arrow appears in the center of *flankers*, or arrows that the participant should ignore. Those flankers can be congruent (>>>>>) or incongruent (<<><<).
-
-A trial for the Flanker Task written with jsPsych might look like this:
-
-```javascript
-var trial = {
-  type: 'html-keyboard-response',
-  stimulus: '<<<<<',
-  choices: ['f','j'],
-  data: {
-    stimulus_type: 'congruent',
-    target_direction: 'left'
-  }
-}
-```
-
-Note the use of the data parameter to add a property `stimulus_type` with the value `congruent` and a property `target_direction` with the value `left`. Having these properties recorded directly in the data simplifies data analysis, making it easy to aggregate data by `stimulus_type` and/or `target_direction`.
-
-## Inter-trial interval
-
-The default inter-trial interval (ITI) in jsPsych is 0 ms. This can be adjusted at the experiment-wide level by changing the `default_iti` parameter in `jsPsych.init()`.
-
-The ITI can also be controlled at the trial level through the `post_trial_gap` parameter. Setting this parameter to a positive integer *x* will cause a blank screen to display after the trial for *x* milliseconds.
-
-```javascript
-var trial = {
-  type: 'html-keyboard-response',
-  stimulus: 'There will be a 1.5 second blank screen after this trial.',
-  post_trial_gap: 1500
-}
-```
-
-## The on_start event
-
-Immediately before a trial runs, there is an opportunity to run an arbitrary function through the `on_start` event handler. This event handler is passed a single argument containing an *editable* copy of the trial parameters. This event handler can therefore be used to alter the trial based on the state of the experiment, among other uses.
-
-```javascript
-var trial = {
-  type: 'html-keyboard-response',
-  stimulus: '<<<<<',
-  choices: ['f','j'],
-  data: {
-    stimulus_type: 'congruent',
-    target_direction: 'left'
-  },
-  on_start: function(trial){
-    trial.stimulus = '<<><<';
-    trial.data.stimulus_type = 'incongruent';
-  }
-}
-```
-
-## The on_finish event
-
-After a trial is completed, there is an opportunity to run an arbitrary function through the `on_finish` event handler. This event handler is passed a single argument containing an *editable* copy of the data recorded for that trial. This event handler can therefore be used to update the state of the experiment based on the data collected or modify the data collected.
-
-This can be useful to calculate new data properties that were unknowable at the start of the trial. For example, with the Flanker Task example above, the `on_finish` event could add a new property `correct`.
-
-```javascript
-var trial = {
-  type: 'html-keyboard-response',
-  stimulus: '<<<<<',
-  choices: ['f','j'],
-  data: {
-    stimulus_type: 'congruent',
-    target_direction: 'left'
-  },
-  on_finish: function(data){
-    if(data.key_press == 70){// 70 is the numeric code for f
-      data.correct = true; // can add property correct by modify data object directly
-    } else {
-      data.correct = false;
-    }
-  }
-}
-```
-
-## The on_load event
-
-The `on_load` callback can be added to any trial. The callback will trigger once the trial has completed loading. For most plugins, this will occur once the display has been initially updated but before any user interactions or timed events (e.g., animations) have occurred.
-
-#### Sample use
-```javascript
-var trial = {
-  type: 'image-keyboard-response',
-  stimulus: 'imgA.png',
-  on_load: function() {
-    console.log('The trial just finished loading.');
-  }
-};
-```
-
-## Dynamic parameters
-
-Most plugins allow parameters to be functions. In a typical declaration of a jsPsych trial, parameters have to be known at the start of the experiment. This makes it impossible to alter the content of the trial based on the outcome of previous trials. When functions are used as parameters for a block of trials, the function is evaluated at the start of each trial, and the return value of the function is used as the parameter. This enables dynamic updating of the parameter based on data that a subject has generated.
-
-Here is a sketch of how this functionality could be used to display feedback to a subject in the Flanker Task.
-
-```javascript
-
-var timeline = [];
-
-var trial = {
-  type: 'html-keyboard-response',
-  stimulus: '<<<<<',
-  choices: ['f','j'],
-  data: {
-    stimulus_type: 'congruent',
-    target_direction: 'left'
-  },
-  on_finish: function(data){
-    if(data.key_press == 70){// 70 is the numeric code for f
-      data.correct = true; // can add property correct by modify data object directly
-    } else {
-      data.correct = false;
-    }
-  }
-}
-
-var feedback = {
-  type: 'html-keyboard-response',
-  stimulus: function(){
-    var last_trial_correct = jsPsych.data.get().last(1).values()[0].correct;
-    if(last_trial_correct){
-      return "<p>Correct!</p>";
-    } else {
-      return "<p>Wrong.</p>"
-    }
-  }
-}
-
-timeline.push(trial, feedback);
-
-```

package/docs/plugins/creating-a-plugin.md

@@ -1,79 +0,0 @@
-# Creating a new plugin
-
-Creating new plugins is the way to add new kinds of tasks to jsPsych. A task can be virtually any kind of activity. If it can be implemented in JavaScript, then it almost certainly can be turned into a plugin.
-
-## What's in a plugin file?
-
-Plugin files follow a specific template. Adherence to the template is what allows jsPsych to run a plugin without knowing anything about what the plugin is doing. What makes plugins so flexible is that the template imposes very few requirements on the code. Here's what an empty plugin template looks like:
-
-```
-jsPsych.plugins['plugin-name'] = (function(){
-
-  var plugin = {};
-
-  plugin.info = {
-    name: 'plugin-name',
-    parameters: {
-    }
-  }
-
-  plugin.trial = function(display_element, trial){
-    jsPsych.finishTrial();
-  }
-
-  return plugin;
-
-})();
-```
-
-This plugin will work! It defines a plugin called 'plugin-name', and it does absolutely nothing. However, it won't break the experiment, and jsPsych will understand that this is a valid plugin.
-
-Let's examine it in more detail.
-
-The overall structure of the plugin is defined using a module JavaScript design pattern. This pattern uses a technique called an anonymous closure. This is why the first line has `(function(){` and the last line is `})();`. The details aren't important, but if you want to learn more about it, [this is a nice overview](http://www.adequatelygood.com/JavaScript-Module-Pattern-In-Depth.html). The reason this pattern is useful is because it allows for persistent state and private scope. In other words, the plugin is isolated and can't be altered by other plugins.
-
-The module, created by the `(function(){`  `})();` expressions, contains an object called `plugin` that has two properties, `info` and `trial`. The `plugin` object is returned at the end of the module, which is what assigns the defined properties of `plugin` to `jsPsych['plugin-name']`.
-
-### plugin.trial
-
-The `trial` method is responsible for running a single trial. There are two parameters that are passed into the trial method. The first, `display_element`, is the DOM element where jsPsych content is being rendered. This parameter will be an `HTMLElement`. Generally, you don't need to worry about this parameter being in the correct format, and can assume that it is an `HMTLElement` and use methods of that class. The second, `trial`, is an object containing all of the parameters specified in the corresponding TimelineNode.
-
-The only requirement for the `trial` method is that it calls `jsPsych.finishTrial()` when it is done. This is how jsPsych knows to advance to the next trial in the experiment (or end the experiment if it is the last trial). The plugin can do whatever it needs to do before that point.
-
-Of course, there are other things that you will probably want the plugin to do besides just end. Here are some examples:
-
-#### Change the content of the display
-
-There are a few ways to change the content of the display. The `display_element` parameter of the trial method contains the DOM element for displaying content, so you can use various JavaScript methods for interaction with the display element. A common one is to change the `innerHTML`.
-
-```javascript
-var html_content = '<p>This is the first paragraph</p>';
-html_content += '<p>This is the second paragraph</p>';
-
-display_element.innerHTML = html_content;
-```
-It is often appropriate to use `innerHTML` to clear the display at the end of a trial:
-
-```javascript
-// clear the display
-display_element.innerHTML = '';
-```
-
-#### Write data
-
-Plugins exist to collect data, so saving data is obviously a crucial thing to do. You can pass an object of data as the parameter to `jsPsych.finishTrial()`:
-
-```javascript
-var data = {
-  correct: true,
-  rt: 350
-}
-
-jsPsych.finishTrial(data)
-```
-
-The data recorded will be that `correct` is `true` and that `rt` is `350`. Additional data for the trial will also be collected automatically by the jsPsych library.
-
-## The plugin template
-
-An empty plugin template is included in the `plugins/template` folder.

package/docs/plugins/jspsych-animation.md

@@ -1,40 +0,0 @@
-# jspsych-animation
-
-This plugin displays a sequence of images at a fixed frame rate. The sequence can be looped a specified number of times. The subject is free to respond at any point during the animation, and the time of the response is recorded.
-
-## Parameters
-
-In addition to the [parameters available in all plugins](overview.md#parameters-available-in-all-plugins), this plugin accepts the following parameters. Parameters with a default value of *undefined* must be specified. Other parameters can be left unspecified if the default value is acceptable.
-
-Parameter | Type | Default Value | Description
-----------|------|---------------|------------
-stimuli | array | *undefined* | Each element of the array is a path to an image file.
-frame_time | numeric | 250 | How long to display each image (in milliseconds).
-frame_isi | numeric | 0 | If greater than 0, then a gap will be shown between each image in the sequence. This parameter specifies the length of the gap.
-sequence_reps | numeric | 1 | How many times to show the entire sequence. There will be no gap (other than the gap specified by `frame_isi`) between repetitions.
-choices | array of keycodes | `jsPsych.ALL_KEYS` | This array contains the keys that the subject is allowed to press in order to respond to the stimulus. Keys can be specified as their [numeric key code](http://www.cambiaresearch.com/articles/15/javascript-char-codes-key-codes) or as characters (e.g., `'a'`, `'q'`). The default value of `jsPsych.ALL_KEYS` means that all keys will be accepted as valid responses. Specifying `jsPsych.NO_KEYS` will mean that no responses are allowed.
-prompt | string | null | This string can contain HTML markup. Any content here will be displayed below the stimulus. The intention is that it can be used to provide a reminder about the action the subject is supposed to take (e.g., which key(s) to press).
-render_on_canvas | boolean | true | If true, the images will be drawn onto a canvas element. This prevents a blank screen (white flash) between consecutive images in some browsers, like Firefox and Edge. If false, the image will be shown via an img element, as in previous versions of jsPsych.
-
-## Data Generated
-
-In addition to the [default data collected by all plugins](overview.md#data-collected-by-plugins), this plugin collects the following data for each trial.
-
-Name | Type | Value
------|------|------
-animation_sequence | JSON | An array, encoded in JSON format. Each element of the array is an object that represents a stimulus in the animation sequence. Each object has a `stimulus` property, which is the image that was displayed, and a `time` property, which is the time in ms, measured from when the sequence began, that the stimulus was displayed.
-responses | JSON | An array, encoded in JSON format. Each element of the array is an object representing a response given by the subject. Each object has a `stimulus` property, indicating which image was displayed when the key was pressed, an `rt` property, indicating the time of the key press relative to the start of the animation, and a `key_press` property, indicating which key was pressed.
-
-## Examples
-
-#### Displaying a single sequence multiple times
-
-```javascript
-var animation_sequence = ["img/face_1.jpg", "img/face_2.jpg", "img/face_3.jpg", "img/face_4.jpg", "img/face_3.jpg", "img/face_2.jpg"];
-
-var animation_trial = {
-    type: 'animation',
-    stimuli: animation_sequence,
-    sequence_reps: 3
-};
-```