jspsych 6.3.0 → 7.1.1

package/docs/core_library/jspsych-randomization.md

@@ -1,397 +0,0 @@
-# jsPsych.randomization
-
-The jsPsych.randomization module contains methods that are useful for generating random lists of trial variables.
-
----
-
-## jsPsych.randomization.factorial
-
-```
-jsPsych.randomization.factorial(factors, repetitions, unpack)
-```
-
-### Parameters
-
-| Parameter   | Type    | Description                              |
-| ----------- | ------- | ---------------------------------------- |
-| factors     | object  | The `factors` object should contain a property for each different factor. Each property-factor should have a value of an array, with each element of the array corresponding to a level of the factor. |
-| repetitions | integer | The number of times to repeat each unique combination of the factors in the output sample. |
-| unpack      | boolean | If `true` then the output will be an object with a property for each factor in the original `factors` object. The value of each property-factor will be an array containing the levels of the factor in a random order. The order will be consistent across each property-factor (e.g., the first element of each property-factor will specify one unique combination of the factors). If `false`, then the return value will be an array of objects where each property-factor contains only a single value. |
-
-### Return value
-
-The return value depends on the `unpack` parameter. See description of the parameter above, and examples below.
-
-### Description
-
-This method takes a list of factors and their levels, and creates a full factorial design by creating each unique combination of the factors. The returned set of combinations is in a random order.
-
-### Examples
-
-#### Create full factorial design
-```javascript
-var factors = {
-	stimulus: ['a.jpg', 'b.jpg'],
-	ms_delay: [100, 200]
-}
-
-var full_design = jsPsych.randomization.factorial(factors, 1);
-
-/*
-output:
-full_design = [
-	{stimulus: 'a.jpg', ms_delay: 200},
-	{stimulus: 'b.jpg', ms_delay: 200},
-	{stimulus: 'b.jpg', ms_delay: 100},
-	{stimulus: 'a.jpg', ms_delay: 100},
-]
-*/
-```
-
-#### Create full factorial design with repeats
-```javascript
-var factors = {
-	stimulus: ['a.jpg', 'b.jpg'],
-	ms_delay: [100, 200]
-}
-
-var full_design = jsPsych.randomization.factorial(factors, 2);
-
-/*
-output:
-full_design = [
-	{stimulus: 'b.jpg', ms_delay: 200},
-	{stimulus: 'b.jpg', ms_delay: 100},
-	{stimulus: 'b.jpg', ms_delay: 100},
-	{stimulus: 'a.jpg', ms_delay: 100},
-	{stimulus: 'a.jpg', ms_delay: 200},
-	{stimulus: 'b.jpg', ms_delay: 200},
-	{stimulus: 'a.jpg', ms_delay: 100},
-	{stimulus: 'a.jpg', ms_delay: 200},
-]
-*/
-```
-
-#### Create full factorial design, unpacked
-```javascript
-var factors = {
-	stimulus: ['a.jpg', 'b.jpg'],
-	ms_delay: [100, 200]
-}
-
-var full_design = jsPsych.randomization.factorial(factors, 1, true);
-
-/*
-output:
-full_design = {
-	stimulus: ['a.jpg','b.jpg','b.jpg','a.jpg'],
-	ms_delay: [200, 100, 200, 100]
-]
-*/
-```
-
----
-## jsPsych.randomization.randomID
-
-```
-jsPsych.randomization.randomID(length)
-```
-
-### Parameters
-
-| Parameter | Type    | Description                             |
-| --------- | ------- | --------------------------------------- |
-| length    | integer | The length of the randomly generated ID |
-
-### Return value
-
-Returns a string of length `length` where each character is randomly selected from the numbers 0-9 and all lowercase English letters a-z.
-
-### Description
-
-Generates a random string that is likely to be unique. If length is undefined, then the string length is 32.
-
-### Example
-
-```javascript
-
-console.log(jsPsych.randomization.randomID());
-// outputs: "t7dwz0e713pc8juuaayyfvpkdd9un239"
-
-console.log(jsPsych.randomization.randomID(8));
-// outputs: "3xtpcbck"
-
-```
-
----
-## jsPsych.randomization.repeat
-
-```
-jsPsych.randomization.repeat(array, repetitions, unpack)
-```
-
-### Parameters
-
-| Parameter   | Type             | Description                              |
-| ----------- | ---------------- | ---------------------------------------- |
-| array       | array            | The array of values to randomize & repeat. |
-| repetitions | integer or array | The number of times to repeat each element of the `array` in the final sample. If this parameter is defined as an integer, then each element of `array` is repeated the same number of times. This parameter can also be an array of the same length as `array`, in which case each element of `array` will be repeated the number of times defined in the corresponding position of the `repetitions` array. |
-| unpack      | boolean          | If each element of `array` is an object with an equivalent set of properties, then setting `unpack` to `true` will make the return value an object with a property for each of the unique properties among the elements of the `array`. Each property in the output object will be an array containing the values for that property in the randomized order. The order will be consistent across properties. If this is `false` then the output is just an array containing a randomized order of the original `array` elements. |
-
-### Return value
-
-The return value depends on the `unpack` parameter. See description of the parameter above, and examples below.
-
-### Description
-
-This method takes an array of values and generates a new random order of the array, with the option of repeating each element of the array a specified number of times.
-
-If the array elements are objects with the same set of properties, then this method can optionally return a single object where each property is a randomized order of the properties defined in the original set of objects. This is useful for randomizing sets of parameters that are used to define a jsPsych block.
-
-### Examples
-
-#### Shuffle an array, no repeats
-
-```javascript
-
-var myArray = [1,2,3,4,5];
-var shuffledArray = jsPsych.randomization.repeat(myArray, 1);
-
-// output: shuffledArray = [3,2,4,1,5]
-```
-
-#### Shuffle an array with repeats
-
-```javascript
-
-var myArray = [1,2,3,4,5];
-var shuffledArray = jsPsych.randomization.repeat(myArray, 2);
-
-// output: shuffledArray = [1,3,4,2,2,4,5,1,5,3]
-```
-
-#### Shuffle an array of objects
-
-```javascript
-
-var trial1 = {
-	stimulus: 'img/faceA.jpg',
-	correct_key: 'p',
-	person_name: 'Joe'
-}
-
-var trial2 = {
-	stimulus: 'img/faceB.jpg',
-	correct_key: 'p',
-	person_name: 'Fred'
-}
-
-var trial3 = {
-	stimulus: 'img/faceC.jpg',
-	correct_key: 'q',
-	person_name: 'Mary'
-}
-
-var myArray = [ trial1, trial2, trial3 ];
-var shuffledArray = jsPsych.randomization.repeat(myArray, 2);
-
-// output: shuffledArray = [ trial1, trial3, trial3, trial2, trial1, trial2 ]
-```
-
-#### Shuffle an array of objects, with unpack
-
-```javascript
-
-var trial1 = {
-	stimulus: 'img/faceA.jpg',
-	correct_key: 'p',
-	person_name: 'Joe'
-}
-
-var trial2 = {
-	stimulus: 'img/faceB.jpg',
-	correct_key: 'p',
-	person_name: 'Fred'
-}
-
-var trial3 = {
-	stimulus: 'img/faceC.jpg',
-	correct_key: 'q',
-	person_name: 'Mary'
-}
-
-var myArray = [ trial1, trial2, trial3 ];
-var shuffledArray = jsPsych.randomization.repeat(myArray, 2, true);
-
-/*
-output: shuffledArray = {
-	stimulus: ['img/faceB.jpg','img/faceA.jpg','img/faceC.jpg','img/faceA.jpg','img/faceC.jpg','img/faceB.jpg'],
-	correct_key: ['p', 'p', 'q', 'p', 'q', 'p'],
-	person_name: ['Fred', 'Joe', 'Mary', 'Joe', 'Mary', 'Fred']
-}
-*/
-```
----
-## jsPsych.randomization.sampleWithReplacement
-
-```
-jsPsych.randomization.sampleWithReplacement(array, sampleSize, weights)
-```
-
-### Parameters
-
-| Parameter  | Type    | Description                              |
-| ---------- | ------- | ---------------------------------------- |
-| array      | array   | The array of values to sample from       |
-| sampleSize | numeric | The number of samples to draw            |
-| weights    | array   | The relative weight of each element in `array`. This array is normalized, so the values do not need to sum to 1. The length must match the length of `array`. |
-
-### Return value
-
-An array containing the sample.
-
-### Description
-
-This method returns a sample drawn at random from a set of values with replacement. The relative probability of drawing each item can be controlled by specifying the `weights`.
-
-### Examples
-
-#### Sample with equal probability
-
-```javascript
-
-var myArray = [1,2,3,4,5];
-var sample = jsPsych.randomization.sampleWithReplacement(myArray, 10);
-
-// output: sample = [3, 1, 2, 2, 5, 1, 4, 3, 1, 5];
-```
-
-#### Sample with unequal probability
-
-```javascript
-
-var myArray = [1,2,3,4,5];
-var sample = jsPsych.randomization.sampleWithReplacement(myArray, 10, [6,1,1,1,1]);
-
-// output: sample = [3, 4, 5, 1, 2, 1, 3, 1, 1, 1];
-```
-
----
-## jsPsych.randomization.sampleWithoutReplacement
-
-```
-jsPsych.randomization.sampleWithoutReplacement(array, sampleSize)
-```
-
-### Parameters
-
-| Parameter  | Type    | Description                        |
-| ---------- | ------- | ---------------------------------- |
-| array      | array   | The array of values to sample from |
-| sampleSize | numeric | The number of samples to draw      |
-
-### Return value
-
-An array containing the sample.
-
-### Description
-
-This method returns a sample drawn at random from a set of values without replacement. The sample size must be less than or equal to the length of the array.
-
-### Examples
-
-#### Sample without replacement
-
-```javascript
-
-var myArray = [1,2,3,4,5];
-var sample = jsPsych.randomization.sampleWithoutReplacement(myArray, 2);
-
-// output: sample = [3,2];
-```
-
----
-## jsPsych.randomization.shuffle
-
-```
-jsPsych.randomization.shuffle(array)
-```
-
-### Parameters
-
-| Parameter | Type  | Description                    |
-| --------- | ----- | ------------------------------ |
-| array     | array | The array of values to shuffle |
-
-### Return value
-
-Returns an array with the same elements as the input array in a random order.
-
-### Description
-
-A simple method for shuffling the order of an array.
-
-### Examples
-
-#### Shuffle an array
-
-```javascript
-
-var myArray = [1,2,3,4,5];
-var shuffledArray = jsPsych.randomization.shuffle(myArray);
-
-// output: shuffledArray = [3,2,4,1,5]
-```
-
----
-## jsPsych.randomization.shuffleNoRepeats
-
-```
-jsPsych.randomization.shuffleNoRepeats(array, equalityTest)
-```
-
-### Parameters
-
-| Parameter    | Type     | Description                              |
-| ------------ | -------- | ---------------------------------------- |
-| array        | array    | The array of values to shuffle           |
-| equalityTest | function | A function to use to evaluate the equality of neighbors in the array. The function should accept two parameters, which are the two elements to be tested. It should return `true` if they are equal and `false` if not. The default function, if none is specified, is to use the `===` operator. This will work for primitive values, but fail for Objects and Arrays. An example function is given below in the examples. |
-
-### Return value
-
-Returns an array with the same elements as the input array in a random order, with no repeating neighbors.
-
-### Description
-
-Shuffle an array, ensuring that neighboring elements in the array are different.
-
-*Warning: if you provide an array that has very few valid permutations with no neighboring elements, then this method will fail and cause the browser to hang.*
-
-### Examples
-
-#### Basic example
-
-```javascript
-
-var myArray = [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5];
-var shuffledArray = jsPsych.randomization.shuffleNoRepeats(myArray);
-
-// output: shuffledArray = [2, 3, 5, 1, 2, 4, 1, 5, 4, 1, 3, 5, 4, 3, 2]
-```
-
-#### Custom equalityTest
-
-```javascript
-var myObjects = [
-  {color:"blue"},
-	{color:"red"},
-	{color:"yellow"},
-	{color:"orange"}
-];
-
-var repeatedSet = jsPsych.randomization.repeat(myObjects,3);
-var shuffled = jsPsych.randomization.shuffleNoRepeats(repeatedSet, function(a,b) { return a.color === b.color });
-
-// console.log(JSON.stringify(shuffled))
-// "[{"color":"red"},{"color":"yellow"},{"color":"blue"},{"color":"yellow"},{"color":"orange"},{"color":"red"},{"color":"yellow"},{"color":"orange"},{"color":"blue"},{"color":"orange"},{"color":"red"},{"color":"blue"}]"
-```

package/docs/core_library/jspsych-turk.md

@@ -1,102 +0,0 @@
-# jsPsych.turk
-
-The jsPsych.turk module contains functions for interacting with Mechanical Turk. 
-
----
-## jsPsych.turk.submitToTurk
-
-```
-jsPsych.turk.submitToTurk(data)
-```
-
-### Parameters
-
-Parameter | Type | Description
-----------|------|------------
-data | object | The `data` parameter is an object of `key: value` pairs. Any pairs in the `data` parameter will be saved by Mechanical Turk, and can be downloaded in a CSV file through the Mechanical Turk interface. **Important**: the `data` parameter must contain at least one `key: value` pair, even just a dummy value, or the HIT will not be submitted correctly.
-
-### Return value
-
-Returns nothing.
-
-### Description 
-
-This method will submit a HIT to Mechanical Turk, causing the HIT to finish. 
-
-This method will only work when called from within the mechanical turk website. If you are using an external HIT to send workers to your own server, this method will not work on an externally hosted page. It will work if your external content is loaded in the iframe on the Mechanical Turk website.
-
-### Example
-
-```html
-
-<p>Enter the code you were given:</p>
-<input type="text" id="code"></input>
-<button onclick="sendData();">Submit HIT</button>
-
-<script>
-// this content must be loaded in the iframe on the mechanical turk website.
-// usually, this means that the content is part of your 'recruitment ad', the
-// page the workers can see when they are deciding whether or not to accept a HIT.
-// one option is to include a simple form on this page that workers submit, with a
-// special code that they get at the end of the experiment.
-
-function sendData() {
-  jsPsych.turk.submitToTurk({
-    code: document.getElementById('code').value
-  });
-}
-</script>
-```
-
----
-
-## jsPsych.turk.turkInfo
-
-```
-jsPsych.turk.turkInfo()
-```
-
-### Parameters
-
-None.
-
-### Return value
-
-Returns an object with six properties:
-
-* `.assignmentId` contains the assignment ID string of the HIT.
-* `.hitId` contains the HIT ID.
-* `.workerId` contains the worker ID of the worker completing the HIT.
-* `.turkSubmitTo` contains the URL for submitting the HIT. This parameter is used in the `jsPsych.turk.submitToTurk` method, and is probably not useful outside of that context.
-* `.previewMode` is a boolean value indicating whether or not the worker has accepted the HIT yet. If the page is viewed inside Mechancial Turk and the worker has not clicked 'Accept HIT' then this will be true. If the page is viewed outside Mechanical Turk or the worker has acccepted the HIT, then it will be false.
-* `.outsideTurk` is a boolean value indicating if the page is being viewed within Mechanical Turk, or if it is being viewed from another source (e.g., someone directly going to the page URL instead of going through mturk).
-
-### Description 
-
-This method returns basic information about the current Mechanical Turk session, including the worker ID, assignment ID, and HIT ID.
-
-### Example
-
-```javascript
-
-var turkInfo = jsPsych.turk.turkInfo();
-
-alert('Worker ID is: ' + turkInfo.workerId);
-
-alert('Assignment ID is: ' + turkInfo.assignmentId);
-
-alert('HIT ID is: ' + turkInfo.hitId);
-
-// true if the page is viewed within Mechanical Turk, 
-// but worker has not accepted the HIT yet.
-// false if the page is viewed outside Mechanical Turk,
-// OR the worker has accepted the HIT.
-alert('Preview mode? ' + turkInfo.previewMode); 
-
-// true if the page is viewed outside mechanical turk,
-// false otherwise.
-alert('Outside turk? ' + turkInfo.outsideTurk);
-```
-
-
-

package/docs/extensions/extensions.md

@@ -1,83 +0,0 @@
-# Extensions
-
-Extensions are jsPsych modules that can interface with any plugin to extend the functionality of the plugin. A canonical example of an extension is eye tracking. An eye tracking extension allows a plugin to gather gaze data and add it to the plugin's data object.
-
-## Using an Extension
-
-To use an extension in an experiment, you'll load the extension file via a `<script>` tag (just like adding a plugin) and then initialize the extension in the parameters of `jsPsych.init()`.
-
-```html
-<head>
-  <script src="jspsych/jspsych.js"></script>
-  <script src="jspsych/extensions/some-extension.js"></script>
-</head>
-```
-
-```js
-jsPsych.init({
-  timeline: [...],
-  extensions: [
-    {type: 'some-extension', params: {...} }
-  ]
-})
-```
-
-To enable an extension during a trial, add the extension to the `extensions` list for the trial. Some extensions may also support or require an object of parameters to configure the extension:
-
-```js
-var trial = {
-  extensions: [
-    {type: 'some-extension', params: {...} }
-  ]
-}
-```
-
-## List of Extensions
-
-Extension | Description
------- | -----------
-[jspsych&#8209;ext&#8209;webgazer.js](/extensions/jspsych-ext-webgazer.md) | Enables eye tracking using the [WebGazer](https://webgazer.cs.brown.edu/) library.
-
-## Writing an Extension
-
-To create a new extension you must create an object that supports a few event callbacks. A barebones extension file looks like this:
-
-```js
-jsPsych.extensions['new-extension'] = (function () {
-
-  var extension = {};
-
-  extension.initialize = function(params){
-    // params are passed from the extensions parameter in jsPsych.init
-  }
-  
-  extension.on_start = function(params){
-    // params are passed from the extensions parameter in the trial object
-  }
-
-  extension.on_load = function(params){
-    // params are passed from the extensions parameter in the trial object
-  }
-
-  extension.on_finish = function(params){
-    // params are passed from the extensions parameter in the trial object
-    return {
-      // any data that the extension returns here will be added to the trial data
-    }
-  }
-  
-  return extension;
-});
-```
-
-The four events that an extension must support are shown in the sample code.
-
-`extension.initialize` is called with `jsPsych.init()`. This is where setup code for the extension can happen. This event will happen once per experiment, unlike the other events which occur with each trial. The `params` object can include whatever parameters are necessary to configure the extension. The `params` object is passed from the call to `jsPsych.init()` to the `extension.initialize` method. `extension.initialize` must return a `Promise` that resolves when the extension is finished initializing. 
-
-`extension.on_start` is called at the start of the plugin execution, prior to calling `plugin.trial`. This is where trial-specific initialization can happen, such as creating empty containers to hold data or resetting internal state. The `params` object is passed from the declaration of the extension in the trial object. You can use `params` to customize the behavior of the extension for each trial.
-
-`extension.on_load` is called after `plugin.trial` has executed, which is typically when the plugin has finished executing initial DOM-modifying code and has set up various event listeners. This is where the extension can begin actively interacting with the DOM and recording data. The `params` object is passed from the declaration of the extension in the trial object. You can use `params` to customize the behavior of the extension for each trial.
-
-`extension.on_finish` is called after the plugin completes. This can be used for any teardown at the end of the trial. This method should return an object of data to append to the plugin's data. Note that this event fires *before* the `on_finish` event for the plugin, so data added by the extension is accessible in any trial `on_finish` event handlers. The `params` object is passed from the declaration of the extension in the trial object. You can use `params` to customize the behavior of the extension for each trial.
-
-The extension can also include any additional methods that are necessary for interacting with it. See the [webgazer extension](/extensions/jspsych-ext-webgazer.md) for an example.

package/docs/extensions/jspsych-ext-webgazer.md

@@ -1,106 +0,0 @@
-# jspsych-ext-webgazer
-
-This extension supports eye tracking through the [WebGazer](https://webgazer.cs.brown.edu/) library. For a narrative description of how to use this extension see the [eye tracking overview](/overview/eye-tracking.md).
-
-## Parameters
-
-### Initialization Parameters
-
-Initialization parameters can be set when calling `jsPsych.init()`
-
-```js
-jsPsych.init({
-  extensions: [
-    {type: 'webgazer', params: {...}}
-  ]
-})
-```
-
-Parameter | Type | Default Value | Description
-----------|------|---------------|------------
-webgazer  | object | `undefined` | You can explicitly pass a reference to a loaded instance of the webgazer.js library. If no explicit reference is passed then the extension will look for a global `webgazer` object. If you are loading webgazer.js via a `<script>` tag you do not need to set this parameter in most circumstances.
-round_predictions | bool | true | Whether to round the `x`,`y` coordinates predicted by WebGazer to the nearest whole number. This *greatly* reduces the size of the data, as WebGazer records data to 15 decimal places by default. Given the noise of the system, there's really no need to record data to this level of precision.
-
-### Trial Parameters
-
-Trial parameters can be set when adding the extension to a trial object.
-
-```js
-var trial = {
-  type: '...',
-  extensions: [
-    {type: 'webgazer', params: {...}}
-  ]
-}
-```
-
-Parameter | Type | Default Value | Description
-----------|------|---------------|------------
-targets | array | [] | A list of elements on the page that you would like to record the coordinates of for comparison with the WebGazer data. Each entry in the array should be a valid [CSS selector string](https://www.w3schools.com/cssref/css_selectors.asp) that identifies the element. The selector string should be valid for exactly one element on the page. If the selector is valid for more than one element then only the first matching element will be recorded.
-
-## Data Generated
-
-Name | Type | Value
------|------|------
-webgazer_data | array | An array of objects containing gaze data for the trial. Each object has an `x`, a `y`, and a `t` property. The `x` and `y` properties specify the gaze location in pixels and `t` specifies the time in milliseconds since the start of the trial.
-webgazer_targets | array | An array of objects contain the pixel coordinates of elements on the screen specified by the `.targets` parameter. Each object contains a `selector` property, containing the CSS selector string used to find the element, plus `top`, `bottom`, `left`, and `right` parameters which specify the [bounding rectangle](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect) of the element. 
-
-## Functions
-
-In addition to the jsPsych webgazer-* plugins, the jsPsych webgazer extension provides a set of functions that allow the researcher to interact more directly with WebGazer. These functions can be called at any point during an experiment, and are crucial for building trial plugins that interact with WebGazer. All of the functions below must be prefixed with `jsPsych.extensions.webgazer` (e.g. `jsPsych.extensions.webgazer.faceDetected()`).
-
-### faceDetected()
-
-Returns `true` if WebGazer is ready to make predictions (`webgazer.getTracker().predictionReady` is `true`).
-
-### showPredictions()
-
-Turns on WebGazer's real-time visualization of predicted gaze location.
-
-### hidePredictions()
-
-Turns off WebGazer's real-time visualization of predicted gaze location.
-
-### showVideo()
-
-Turns on a display of the webcam image, guiding box for positioning the face, and WebGazer's estimate of the location of facial landmarks.
-
-### hideVideo()
-
-Turns off the camera display.
-
-### resume()
-
-Turns on gaze prediction. The extension will automatically handle this for you in most cases. You probably only need to use this if you are writing your own plugin that interfaces directly with WebGazer.
-
-### pause()
-
-Turns off gaze prediction. The extension will automatically handle this for you in most cases. You probably only need to use this if you are writing your own plugin that interfaces directly with WebGazer.
-
-### startMouseCalibration()
-
-Turns on mouse movement and mouse clicks as calibration events. While the `webgazer-calibration` plugin can also be used to run a parmeterized calibration routine, this calibration function call allows you to continuously calibrate WebGazer to any mouse movements or clicks throughout the experiment. For example, any *-button-response trial would also function as a WebGazer calibration event. 
-
-### stopMouseCalibration()
-
-Stops WebGazer from using mouse movements and mouse clicks as calibration events.
-
-### calibratePoint(x, y)
-
-Instructs WebGazer to register the location `x`, `y` (in screen pixel coordinates) as a calibration event. Can be used for passive viewing calibration, i.e., instructing participants to fixate at a particular location.
-
-### setRegressionType(regression_type)
-
-Change the method that WebGazer is using to perform feature -> location regression. Valid options are `ridge`, `weightedRidge`, and `threadedRidge`. See the WebGazer docs for more information about these options.
-The extension uses the default mode specified by WebGazer (currently `ridge`).
-
-### getCurrentPrediction()
-
-Get the current predicted gaze location from WebGazer. Returns an object with `x`, `y`, and `eyeFeature` properties. This function is asynchronus, so proper use requires either the `await` keyword in the context of another `async function` or using `.then()`. 
-
-```js
-jsPsych.extensions.webgazer.getCurrentPrediction().then(function(data){
-  console.log(`Currently looking at coordinate ${data.x}, ${data.y}`)
-});
-```
-