text: var jsPsychModule = (function (exports) {
      'use strict';
  
      /*! *****************************************************************************
      Copyright (c) Microsoft Corporation.
  
      Permission to use, copy, modify, and/or distribute this software for any
      purpose with or without fee is hereby granted.
  
      THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
      REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
      AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
      INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
      LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
      OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
      PERFORMANCE OF THIS SOFTWARE.
      ***************************************************************************** */
  
      function __awaiter(thisArg, _arguments, P, generator) {
          function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
          return new (P || (P = Promise))(function (resolve, reject) {
              function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
              function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
              function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
              step((generator = generator.apply(thisArg, _arguments || [])).next());
          });
      }
  
      var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
      // Gets all non-builtin properties up the prototype chain
      const getAllProperties = object => {
      	const properties = new Set();
  
      	do {
      		for (const key of Reflect.ownKeys(object)) {
      			properties.add([object, key]);
      		}
      	} while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
  
      	return properties;
      };
  
      var autoBind = (self, {include, exclude} = {}) => {
      	const filter = key => {
      		const match = pattern => typeof pattern === 'string' ? key === pattern : pattern.test(key);
  
      		if (include) {
      			return include.some(match);
      		}
  
      		if (exclude) {
      			return !exclude.some(match);
      		}
  
      		return true;
      	};
  
      	for (const [object, key] of getAllProperties(self.constructor.prototype)) {
      		if (key === 'constructor' || !filter(key)) {
      			continue;
      		}
  
      		const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
      		if (descriptor && typeof descriptor.value === 'function') {
      			self[key] = self[key].bind(self);
      		}
      	}
  
      	return self;
      };
  
      var version = "7.2.1";
  
      class MigrationError extends Error {
          constructor(message = "The global `jsPsych` variable is no longer available in jsPsych v7.") {
              super(`${message} Please follow the migration guide at https://www.jspsych.org/7.0/support/migration-v7/ to update your experiment.`);
              this.name = "MigrationError";
          }
      }
      // Define a global jsPsych object to handle invocations on it with migration errors
      window.jsPsych = {
          get init() {
              throw new MigrationError("`jsPsych.init()` was replaced by `initJsPsych()` in jsPsych v7.");
          },
          get data() {
              throw new MigrationError();
          },
          get randomization() {
              throw new MigrationError();
          },
          get turk() {
              throw new MigrationError();
          },
          get pluginAPI() {
              throw new MigrationError();
          },
          get ALL_KEYS() {
              throw new MigrationError('jsPsych.ALL_KEYS was replaced by the "ALL_KEYS" string in jsPsych v7.');
          },
          get NO_KEYS() {
              throw new MigrationError('jsPsych.NO_KEYS was replaced by the "NO_KEYS" string in jsPsych v7.');
          },
      };
  
      /**
       * Finds all of the unique items in an array.
       * @param arr The array to extract unique values from
       * @returns An array with one copy of each unique item in `arr`
       */
      function unique(arr) {
          return [...new Set(arr)];
      }
      function deepCopy(obj) {
          if (!obj)
              return obj;
          let out;
          if (Array.isArray(obj)) {
              out = [];
              for (const x of obj) {
                  out.push(deepCopy(x));
              }
              return out;
          }
          else if (typeof obj === "object" && obj !== null) {
              out = {};
              for (const key in obj) {
                  if (obj.hasOwnProperty(key)) {
                      out[key] = deepCopy(obj[key]);
                  }
              }
              return out;
          }
          else {
              return obj;
          }
      }
  
      var utils = /*#__PURE__*/Object.freeze({
          __proto__: null,
          unique: unique,
          deepCopy: deepCopy
      });
  
      class DataColumn {
          constructor(values = []) {
              this.values = values;
          }
          sum() {
              let s = 0;
              for (const v of this.values) {
                  s += v;
              }
              return s;
          }
          mean() {
              return this.sum() / this.count();
          }
          median() {
              if (this.values.length === 0) {
                  return undefined;
              }
              const numbers = this.values.slice(0).sort(function (a, b) {
                  return a - b;
              });
              const middle = Math.floor(numbers.length / 2);
              const isEven = numbers.length % 2 === 0;
              return isEven ? (numbers[middle] + numbers[middle - 1]) / 2 : numbers[middle];
          }
          min() {
              return Math.min.apply(null, this.values);
          }
          max() {
              return Math.max.apply(null, this.values);
          }
          count() {
              return this.values.length;
          }
          variance() {
              const mean = this.mean();
              let sum_square_error = 0;
              for (const x of this.values) {
                  sum_square_error += Math.pow(x - mean, 2);
              }
              const mse = sum_square_error / (this.values.length - 1);
              return mse;
          }
          sd() {
              const mse = this.variance();
              const rmse = Math.sqrt(mse);
              return rmse;
          }
          frequencies() {
              const unique = {};
              for (const x of this.values) {
                  if (typeof unique[x] === "undefined") {
                      unique[x] = 1;
                  }
                  else {
                      unique[x]++;
                  }
              }
              return unique;
          }
          all(eval_fn) {
              for (const x of this.values) {
                  if (!eval_fn(x)) {
                      return false;
                  }
              }
              return true;
          }
          subset(eval_fn) {
              const out = [];
              for (const x of this.values) {
                  if (eval_fn(x)) {
                      out.push(x);
                  }
              }
              return new DataColumn(out);
          }
      }
  
      // private function to save text file on local drive
      function saveTextToFile(textstr, filename) {
          const blobToSave = new Blob([textstr], {
              type: "text/plain",
          });
          let blobURL = "";
          if (typeof window.webkitURL !== "undefined") {
              blobURL = window.webkitURL.createObjectURL(blobToSave);
          }
          else {
              blobURL = window.URL.createObjectURL(blobToSave);
          }
          const link = document.createElement("a");
          link.id = "jspsych-download-as-text-link";
          link.style.display = "none";
          link.download = filename;
          link.href = blobURL;
          link.click();
      }
      // this function based on code suggested by StackOverflow users:
      // http://stackoverflow.com/users/64741/zachary
      // http://stackoverflow.com/users/317/joseph-sturtevant
      function JSON2CSV(objArray) {
          const array = typeof objArray != "object" ? JSON.parse(objArray) : objArray;
          let line = "";
          let result = "";
          const columns = [];
          for (const row of array) {
              for (const key in row) {
                  let keyString = key + "";
                  keyString = '"' + keyString.replace(/"/g, '""') + '",';
                  if (!columns.includes(key)) {
                      columns.push(key);
                      line += keyString;
                  }
              }
          }
          line = line.slice(0, -1); // removes last comma
          result += line + "\r\n";
          for (const row of array) {
              line = "";
              for (const col of columns) {
                  let value = typeof row[col] === "undefined" ? "" : row[col];
                  if (typeof value == "object") {
                      value = JSON.stringify(value);
                  }
                  const valueString = value + "";
                  line += '"' + valueString.replace(/"/g, '""') + '",';
              }
              line = line.slice(0, -1);
              result += line + "\r\n";
          }
          return result;
      }
      // this function is modified from StackOverflow:
      // http://stackoverflow.com/posts/3855394
      function getQueryString() {
          const a = window.location.search.substr(1).split("&");
          const b = {};
          for (let i = 0; i < a.length; ++i) {
              const p = a[i].split("=", 2);
              if (p.length == 1)
                  b[p[0]] = "";
              else
                  b[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
          }
          return b;
      }
  
      class DataCollection {
          constructor(data = []) {
              this.trials = data;
          }
          push(new_data) {
              this.trials.push(new_data);
              return this;
          }
          join(other_data_collection) {
              this.trials = this.trials.concat(other_data_collection.values());
              return this;
          }
          top() {
              if (this.trials.length <= 1) {
                  return this;
              }
              else {
                  return new DataCollection([this.trials[this.trials.length - 1]]);
              }
          }
          /**
           * Queries the first n elements in a collection of trials.
           *
           * @param n A positive integer of elements to return. A value of
           *          n that is less than 1 will throw an error.
           *
           * @return First n objects of a collection of trials. If fewer than
           *         n trials are available, the trials.length elements will
           *         be returned.
           *
           */
          first(n = 1) {
              if (n < 1) {
                  throw `You must query with a positive nonzero integer. Please use a
                 different value for n.`;
              }
              if (this.trials.length === 0)
                  return new DataCollection();
              if (n > this.trials.length)
                  n = this.trials.length;
              return new DataCollection(this.trials.slice(0, n));
          }
          /**
           * Queries the last n elements in a collection of trials.
           *
           * @param n A positive integer of elements to return. A value of
           *          n that is less than 1 will throw an error.
           *
           * @return Last n objects of a collection of trials. If fewer than
           *         n trials are available, the trials.length elements will
           *         be returned.
           *
           */
          last(n = 1) {
              if (n < 1) {
                  throw `You must query with a positive nonzero integer. Please use a
                 different value for n.`;
              }
              if (this.trials.length === 0)
                  return new DataCollection();
              if (n > this.trials.length)
                  n = this.trials.length;
              return new DataCollection(this.trials.slice(this.trials.length - n, this.trials.length));
          }
          values() {
              return this.trials;
          }
          count() {
              return this.trials.length;
          }
          readOnly() {
              return new DataCollection(deepCopy(this.trials));
          }
          addToAll(properties) {
              for (const trial of this.trials) {
                  Object.assign(trial, properties);
              }
              return this;
          }
          addToLast(properties) {
              if (this.trials.length != 0) {
                  Object.assign(this.trials[this.trials.length - 1], properties);
              }
              return this;
          }
          filter(filters) {
              // [{p1: v1, p2:v2}, {p1:v2}]
              // {p1: v1}
              let f;
              if (!Array.isArray(filters)) {
                  f = deepCopy([filters]);
              }
              else {
                  f = deepCopy(filters);
              }
              const filtered_data = [];
              for (const trial of this.trials) {
                  let keep = false;
                  for (const filter of f) {
                      let match = true;
                      for (const key of Object.keys(filter)) {
                          if (typeof trial[key] !== "undefined" && trial[key] === filter[key]) ;
                          else {
                              match = false;
                          }
                      }
                      if (match) {
                          keep = true;
                          break;
                      } // can break because each filter is OR.
                  }
                  if (keep) {
                      filtered_data.push(trial);
                  }
              }
              return new DataCollection(filtered_data);
          }
          filterCustom(fn) {
              return new DataCollection(this.trials.filter(fn));
          }
          filterColumns(columns) {
              return new DataCollection(this.trials.map((trial) => Object.fromEntries(columns.filter((key) => key in trial).map((key) => [key, trial[key]]))));
          }
          select(column) {
              const values = [];
              for (const trial of this.trials) {
                  if (typeof trial[column] !== "undefined") {
                      values.push(trial[column]);
                  }
              }
              return new DataColumn(values);
          }
          ignore(columns) {
              if (!Array.isArray(columns)) {
                  columns = [columns];
              }
              const o = deepCopy(this.trials);
              for (const trial of o) {
                  for (const delete_key of columns) {
                      delete trial[delete_key];
                  }
              }
              return new DataCollection(o);
          }
          uniqueNames() {
              const names = [];
              for (const trial of this.trials) {
                  for (const key of Object.keys(trial)) {
                      if (!names.includes(key)) {
                          names.push(key);
                      }
                  }
              }
              return names;
          }
          csv() {
              return JSON2CSV(this.trials);
          }
          json(pretty = false) {
              if (pretty) {
                  return JSON.stringify(this.trials, null, "\t");
              }
              return JSON.stringify(this.trials);
          }
          localSave(format, filename) {
              format = format.toLowerCase();
              let data_string;
              if (format === "json") {
                  data_string = this.json();
              }
              else if (format === "csv") {
                  data_string = this.csv();
              }
              else {
                  throw new Error('Invalid format specified for localSave. Must be "json" or "csv".');
              }
              saveTextToFile(data_string, filename);
          }
      }
  
      class JsPsychData {
          constructor(jsPsych) {
              this.jsPsych = jsPsych;
              // data properties for all trials
              this.dataProperties = {};
              this.reset();
          }
          reset() {
              this.allData = new DataCollection();
              this.interactionData = new DataCollection();
          }
          get() {
              return this.allData;
          }
          getInteractionData() {
              return this.interactionData;
          }
          write(data_object) {
              const progress = this.jsPsych.getProgress();
              const trial = this.jsPsych.getCurrentTrial();
              //var trial_opt_data = typeof trial.data == 'function' ? trial.data() : trial.data;
              const default_data = {
                  trial_type: trial.type.info.name,
                  trial_index: progress.current_trial_global,
                  time_elapsed: this.jsPsych.getTotalTime(),
                  internal_node_id: this.jsPsych.getCurrentTimelineNodeID(),
              };
              this.allData.push(Object.assign(Object.assign(Object.assign(Object.assign({}, data_object), trial.data), default_data), this.dataProperties));
          }
          addProperties(properties) {
              // first, add the properties to all data that's already stored
              this.allData.addToAll(properties);
              // now add to list so that it gets appended to all future data
              this.dataProperties = Object.assign({}, this.dataProperties, properties);
          }
          addDataToLastTrial(data) {
              this.allData.addToLast(data);
          }
          getDataByTimelineNode(node_id) {
              return this.allData.filterCustom((x) => x.internal_node_id.slice(0, node_id.length) === node_id);
          }
          getLastTrialData() {
              return this.allData.top();
          }
          getLastTimelineData() {
              const lasttrial = this.getLastTrialData();
              const node_id = lasttrial.select("internal_node_id").values[0];
              if (typeof node_id === "undefined") {
                  return new DataCollection();
              }
              else {
                  const parent_node_id = node_id.substr(0, node_id.lastIndexOf("-"));
                  const lastnodedata = this.getDataByTimelineNode(parent_node_id);
                  return lastnodedata;
              }
          }
          displayData(format = "json") {
              format = format.toLowerCase();
              if (format != "json" && format != "csv") {
                  console.log("Invalid format declared for displayData function. Using json as default.");
                  format = "json";
              }
              const data_string = format === "json" ? this.allData.json(true) : this.allData.csv();
              const display_element = this.jsPsych.getDisplayElement();
              display_element.innerHTML = '<pre id="jspsych-data-display"></pre>';
              document.getElementById("jspsych-data-display").textContent = data_string;
          }
          urlVariables() {
              if (typeof this.query_string == "undefined") {
                  this.query_string = getQueryString();
              }
              return this.query_string;
          }
          getURLVariable(whichvar) {
              return this.urlVariables()[whichvar];
          }
          createInteractionListeners() {
              // blur event capture
              window.addEventListener("blur", () => {
                  const data = {
                      event: "blur",
                      trial: this.jsPsych.getProgress().current_trial_global,
                      time: this.jsPsych.getTotalTime(),
                  };
                  this.interactionData.push(data);
                  this.jsPsych.getInitSettings().on_interaction_data_update(data);
              });
              // focus event capture
              window.addEventListener("focus", () => {
                  const data = {
                      event: "focus",
                      trial: this.jsPsych.getProgress().current_trial_global,
                      time: this.jsPsych.getTotalTime(),
                  };
                  this.interactionData.push(data);
                  this.jsPsych.getInitSettings().on_interaction_data_update(data);
              });
              // fullscreen change capture
              const fullscreenchange = () => {
                  const data = {
                      event: 
                      // @ts-expect-error
                      document.isFullScreen ||
                          // @ts-expect-error
                          document.webkitIsFullScreen ||
                          // @ts-expect-error
                          document.mozIsFullScreen ||
                          document.fullscreenElement
                          ? "fullscreenenter"
                          : "fullscreenexit",
                      trial: this.jsPsych.getProgress().current_trial_global,
                      time: this.jsPsych.getTotalTime(),
                  };
                  this.interactionData.push(data);
                  this.jsPsych.getInitSettings().on_interaction_data_update(data);
              };
              document.addEventListener("fullscreenchange", fullscreenchange);
              document.addEventListener("mozfullscreenchange", fullscreenchange);
              document.addEventListener("webkitfullscreenchange", fullscreenchange);
          }
          // public methods for testing purposes. not recommended for use.
          _customInsert(data) {
              this.allData = new DataCollection(data);
          }
          _fullreset() {
              this.reset();
              this.dataProperties = {};
          }
      }
  
      class HardwareAPI {
          constructor() {
              /**
               * Indicates whether this instance of jspsych has opened a hardware connection through our browser
               * extension
               **/
              this.hardwareConnected = false;
              //it might be useful to open up a line of communication from the extension back to this page
              //script, again, this will have to pass through DOM events. For now speed is of no concern so I
              //will use jQuery
              document.addEventListener("jspsych-activate", (evt) => {
                  this.hardwareConnected = true;
              });
          }
          /**
           * Allows communication with user hardware through our custom Google Chrome extension + native C++ program
           * @param		mess	The message to be passed to our extension, see its documentation for the expected members of this object.
           * @author	Daniel Rivas
           *
           */
          hardware(mess) {
              //since Chrome extension content-scripts do not share the javascript environment with the page
              //script that loaded jspsych, we will need to use hacky methods like communicating through DOM
              //events.
              const jspsychEvt = new CustomEvent("jspsych", { detail: mess });
              document.dispatchEvent(jspsychEvt);
              //And voila! it will be the job of the content script injected by the extension to listen for
              //the event and do the appropriate actions.
          }
      }
  
      class KeyboardListenerAPI {
          constructor(getRootElement, areResponsesCaseSensitive = false, minimumValidRt = 0) {
              this.getRootElement = getRootElement;
              this.areResponsesCaseSensitive = areResponsesCaseSensitive;
              this.minimumValidRt = minimumValidRt;
              this.listeners = new Set();
              this.heldKeys = new Set();
              this.areRootListenersRegistered = false;
              autoBind(this);
              this.registerRootListeners();
          }
          /**
           * If not previously done and `this.getRootElement()` returns an element, adds the root key
           * listeners to that element.
           */
          registerRootListeners() {
              if (!this.areRootListenersRegistered) {
                  const rootElement = this.getRootElement();
                  if (rootElement) {
                      rootElement.addEventListener("keydown", this.rootKeydownListener);
                      rootElement.addEventListener("keyup", this.rootKeyupListener);
                      this.areRootListenersRegistered = true;
                  }
              }
          }
          rootKeydownListener(e) {
              // Iterate over a static copy of the listeners set because listeners might add other listeners
              // that we do not want to be included in the loop
              for (const listener of Array.from(this.listeners)) {
                  listener(e);
              }
              this.heldKeys.add(this.toLowerCaseIfInsensitive(e.key));
          }
          toLowerCaseIfInsensitive(string) {
              return this.areResponsesCaseSensitive ? string : string.toLowerCase();
          }
          rootKeyupListener(e) {
              this.heldKeys.delete(this.toLowerCaseIfInsensitive(e.key));
          }
          isResponseValid(validResponses, allowHeldKey, key) {
              // check if key was already held down
              if (!allowHeldKey && this.heldKeys.has(key)) {
                  return false;
              }
              if (validResponses === "ALL_KEYS") {
                  return true;
              }
              if (validResponses === "NO_KEYS") {
                  return false;
              }
              return validResponses.includes(key);
          }
          getKeyboardResponse({ callback_function, valid_responses = "ALL_KEYS", rt_method = "performance", persist, audio_context, audio_context_start_time, allow_held_key = false, minimum_valid_rt = this.minimumValidRt, }) {
              if (rt_method !== "performance" && rt_method !== "audio") {
                  console.log('Invalid RT method specified in getKeyboardResponse. Defaulting to "performance" method.');
                  rt_method = "performance";
              }
              const usePerformanceRt = rt_method === "performance";
              const startTime = usePerformanceRt ? performance.now() : audio_context_start_time * 1000;
              this.registerRootListeners();
              if (!this.areResponsesCaseSensitive && typeof valid_responses !== "string") {
                  valid_responses = valid_responses.map((r) => r.toLowerCase());
              }
              const listener = (e) => {
                  const rt = Math.round((rt_method == "performance" ? performance.now() : audio_context.currentTime * 1000) -
                      startTime);
                  if (rt < minimum_valid_rt) {
                      return;
                  }
                  const key = this.toLowerCaseIfInsensitive(e.key);
                  if (this.isResponseValid(valid_responses, allow_held_key, key)) {
                      // if this is a valid response, then we don't want the key event to trigger other actions
                      // like scrolling via the spacebar.
                      e.preventDefault();
                      if (!persist) {
                          // remove keyboard listener if it exists
                          this.cancelKeyboardResponse(listener);
                      }
                      callback_function({ key, rt });
                  }
              };
              this.listeners.add(listener);
              return listener;
          }
          cancelKeyboardResponse(listener) {
              // remove the listener from the set of listeners if it is contained
              this.listeners.delete(listener);
          }
          cancelAllKeyboardResponses() {
              this.listeners.clear();
          }
          compareKeys(key1, key2) {
              if ((typeof key1 !== "string" && key1 !== null) ||
                  (typeof key2 !== "string" && key2 !== null)) {
                  console.error("Error in jsPsych.pluginAPI.compareKeys: arguments must be key strings or null.");
                  return undefined;
              }
              if (typeof key1 === "string" && typeof key2 === "string") {
                  // if both values are strings, then check whether or not letter case should be converted before comparing (case_sensitive_responses in initJsPsych)
                  return this.areResponsesCaseSensitive
                      ? key1 === key2
                      : key1.toLowerCase() === key2.toLowerCase();
              }
              return key1 === null && key2 === null;
          }
      }
  
      /**
       * Parameter types for plugins
       */
      exports.ParameterType = void 0;
      (function (ParameterType) {
          ParameterType[ParameterType["BOOL"] = 0] = "BOOL";
          ParameterType[ParameterType["STRING"] = 1] = "STRING";
          ParameterType[ParameterType["INT"] = 2] = "INT";
          ParameterType[ParameterType["FLOAT"] = 3] = "FLOAT";
          ParameterType[ParameterType["FUNCTION"] = 4] = "FUNCTION";
          ParameterType[ParameterType["KEY"] = 5] = "KEY";
          ParameterType[ParameterType["KEYS"] = 6] = "KEYS";
          ParameterType[ParameterType["SELECT"] = 7] = "SELECT";
          ParameterType[ParameterType["HTML_STRING"] = 8] = "HTML_STRING";
          ParameterType[ParameterType["IMAGE"] = 9] = "IMAGE";
          ParameterType[ParameterType["AUDIO"] = 10] = "AUDIO";
          ParameterType[ParameterType["VIDEO"] = 11] = "VIDEO";
          ParameterType[ParameterType["OBJECT"] = 12] = "OBJECT";
          ParameterType[ParameterType["COMPLEX"] = 13] = "COMPLEX";
          ParameterType[ParameterType["TIMELINE"] = 14] = "TIMELINE";
      })(exports.ParameterType || (exports.ParameterType = {}));
      const universalPluginParameters = {
          /**
           * Data to add to this trial (key-value pairs)
           */
          data: {
              type: exports.ParameterType.OBJECT,
              pretty_name: "Data",
              default: {},
          },
          /**
           * Function to execute when trial begins
           */
          on_start: {
              type: exports.ParameterType.FUNCTION,
              pretty_name: "On start",
              default: function () {
                  return;
              },
          },
          /**
           * Function to execute when trial is finished
           */
          on_finish: {
              type: exports.ParameterType.FUNCTION,
              pretty_name: "On finish",
              default: function () {
                  return;
              },
          },
          /**
           * Function to execute after the trial has loaded
           */
          on_load: {
              type: exports.ParameterType.FUNCTION,
              pretty_name: "On load",
              default: function () {
                  return;
              },
          },
          /**
           * Length of gap between the end of this trial and the start of the next trial
           */
          post_trial_gap: {
              type: exports.ParameterType.INT,
              pretty_name: "Post trial gap",
              default: null,
          },
          /**
           * A list of CSS classes to add to the jsPsych display element for the duration of this trial
           */
          css_classes: {
              type: exports.ParameterType.STRING,
              pretty_name: "Custom CSS classes",
              default: null,
          },
          /**
           * Options to control simulation mode for the trial.
           */
          simulation_options: {
              type: exports.ParameterType.COMPLEX,
              default: null,
          },
      };
  
      const preloadParameterTypes = [
          exports.ParameterType.AUDIO,
          exports.ParameterType.IMAGE,
          exports.ParameterType.VIDEO,
      ];
      class MediaAPI {
          constructor(useWebaudio, webaudioContext) {
              this.useWebaudio = useWebaudio;
              this.webaudioContext = webaudioContext;
              // video //
              this.video_buffers = {};
              // audio //
              this.context = null;
              this.audio_buffers = [];
              // preloading stimuli //
              this.preload_requests = [];
              this.img_cache = {};
              this.preloadMap = new Map();
              this.microphone_recorder = null;
          }
          getVideoBuffer(videoID) {
              return this.video_buffers[videoID];
          }
          initAudio() {
              this.context = this.useWebaudio ? this.webaudioContext : null;
          }
          audioContext() {
              if (this.context !== null) {
                  if (this.context.state !== "running") {
                      this.context.resume();
                  }
              }
              return this.context;
          }
          getAudioBuffer(audioID) {
              return new Promise((resolve, reject) => {
                  // check whether audio file already preloaded
                  if (typeof this.audio_buffers[audioID] == "undefined" ||
                      this.audio_buffers[audioID] == "tmp") {
                      // if audio is not already loaded, try to load it
                      this.preloadAudio([audioID], () => {
                          resolve(this.audio_buffers[audioID]);
                      }, () => { }, (e) => {
                          reject(e.error);
                      });
                  }
                  else {
                      // audio is already loaded
                      resolve(this.audio_buffers[audioID]);
                  }
              });
          }
          preloadAudio(files, callback_complete = () => { }, callback_load = (filepath) => { }, callback_error = (error_msg) => { }) {
              files = unique(files.flat());
              let n_loaded = 0;
              if (files.length == 0) {
                  callback_complete();
                  return;
              }
              const load_audio_file_webaudio = (source, count = 1) => {
                  const request = new XMLHttpRequest();
                  request.open("GET", source, true);
                  request.responseType = "arraybuffer";
                  request.onload = () => {
                      this.context.decodeAudioData(request.response, (buffer) => {
                          this.audio_buffers[source] = buffer;
                          n_loaded++;
                          callback_load(source);
                          if (n_loaded == files.length) {
                              callback_complete();
                          }
                      }, (e) => {
                          callback_error({ source: source, error: e });
                      });
                  };
                  request.onerror = function (e) {
                      let err = e;
                      if (this.status == 404) {
                          err = "404";
                      }
                      callback_error({ source: source, error: err });
                  };
                  request.onloadend = function (e) {
                      if (this.status == 404) {
                          callback_error({ source: source, error: "404" });
                      }
                  };
                  request.send();
                  this.preload_requests.push(request);
              };
              const load_audio_file_html5audio = (source, count = 1) => {
                  const audio = new Audio();
                  const handleCanPlayThrough = () => {
                      this.audio_buffers[source] = audio;
                      n_loaded++;
                      callback_load(source);
                      if (n_loaded == files.length) {
                          callback_complete();
                      }
                      audio.removeEventListener("canplaythrough", handleCanPlayThrough);
                  };
                  audio.addEventListener("canplaythrough", handleCanPlayThrough);
                  audio.addEventListener("error", function handleError(e) {
                      callback_error({ source: audio.src, error: e });
                      audio.removeEventListener("error", handleError);
                  });
                  audio.addEventListener("abort", function handleAbort(e) {
                      callback_error({ source: audio.src, error: e });
                      audio.removeEventListener("abort", handleAbort);
                  });
                  audio.src = source;
                  this.preload_requests.push(audio);
              };
              for (const file of files) {
                  if (typeof this.audio_buffers[file] !== "undefined") {
                      n_loaded++;
                      callback_load(file);
                      if (n_loaded == files.length) {
                          callback_complete();
                      }
                  }
                  else {
                      this.audio_buffers[file] = "tmp";
                      if (this.audioContext() !== null) {
                          load_audio_file_webaudio(file);
                      }
                      else {
                          load_audio_file_html5audio(file);
                      }
                  }
              }
          }
          preloadImages(images, callback_complete = () => { }, callback_load = (filepath) => { }, callback_error = (error_msg) => { }) {
              // flatten the images array
              images = unique(images.flat());
              var n_loaded = 0;
              if (images.length === 0) {
                  callback_complete();
                  return;
              }
              for (var i = 0; i < images.length; i++) {
                  var img = new Image();
                  img.onload = function () {
                      n_loaded++;
                      callback_load(img.src);
                      if (n_loaded === images.length) {
                          callback_complete();
                      }
                  };
                  img.onerror = function (e) {
                      callback_error({ source: img.src, error: e });
                  };
                  img.src = images[i];
                  this.img_cache[images[i]] = img;
                  this.preload_requests.push(img);
              }
          }
          preloadVideo(videos, callback_complete = () => { }, callback_load = (filepath) => { }, callback_error = (error_msg) => { }) {
              // flatten the video array
              videos = unique(videos.flat());
              let n_loaded = 0;
              if (videos.length === 0) {
                  callback_complete();
                  return;
              }
              for (const video of videos) {
                  const video_buffers = this.video_buffers;
                  //based on option 4 here: http://dinbror.dk/blog/how-to-preload-entire-html5-video-before-play-solved/
                  const request = new XMLHttpRequest();
                  request.open("GET", video, true);
                  request.responseType = "blob";
                  request.onload = function () {
                      if (this.status === 200 || this.status === 0) {
                          const videoBlob = this.response;
                          video_buffers[video] = URL.createObjectURL(videoBlob); // IE10+
                          n_loaded++;
                          callback_load(video);
                          if (n_loaded === videos.length) {
                              callback_complete();
                          }
                      }
                  };
                  request.onerror = function (e) {
                      let err = e;
                      if (this.status == 404) {
                          err = "404";
                      }
                      callback_error({ source: video, error: err });
                  };
                  request.onloadend = function (e) {
                      if (this.status == 404) {
                          callback_error({ source: video, error: "404" });
                      }
                  };
                  request.send();
                  this.preload_requests.push(request);
              }
          }
          getAutoPreloadList(timeline_description) {
              /** Map each preload parameter type to a set of paths to be preloaded */
              const preloadPaths = Object.fromEntries(preloadParameterTypes.map((type) => [type, new Set()]));
              const traverseTimeline = (node, inheritedTrialType) => {
                  var _a, _b, _c, _d;
                  const isTimeline = typeof node.timeline !== "undefined";
                  if (isTimeline) {
                      for (const childNode of node.timeline) {
                          traverseTimeline(childNode, (_a = node.type) !== null && _a !== void 0 ? _a : inheritedTrialType);
                      }
                  }
                  else if ((_c = ((_b = node.type) !== null && _b !== void 0 ? _b : inheritedTrialType)) === null || _c === void 0 ? void 0 : _c.info) {
                      // node is a trial with type.info set
                      // Get the plugin name and parameters object from the info object
                      const { name: pluginName, parameters } = ((_d = node.type) !== null && _d !== void 0 ? _d : inheritedTrialType).info;
                      // Extract parameters to be preloaded and their types from parameter info if this has not
                      // yet been done for `pluginName`
                      if (!this.preloadMap.has(pluginName)) {
                          this.preloadMap.set(pluginName, Object.fromEntries(Object.entries(parameters)
                              // Filter out parameter entries with media types and a non-false `preload` option
                              .filter(([_name, { type, preload }]) => preloadParameterTypes.includes(type) && (preload !== null && preload !== void 0 ? preload : true))
                              // Map each entry's value to its parameter type
                              .map(([name, { type }]) => [name, type])));
                      }
                      // Add preload paths from this trial
                      for (const [parameterName, parameterType] of Object.entries(this.preloadMap.get(pluginName))) {
                          const parameterValue = node[parameterName];
                          const elements = preloadPaths[parameterType];
                          if (typeof parameterValue === "string") {
                              elements.add(parameterValue);
                          }
                          else if (Array.isArray(parameterValue)) {
                              for (const element of parameterValue.flat()) {
                                  if (typeof element === "string") {
                                      elements.add(element);
                                  }
                              }
                          }
                      }
                  }
              };
              traverseTimeline({ timeline: timeline_description });
              return {
                  images: [...preloadPaths[exports.ParameterType.IMAGE]],
                  audio: [...preloadPaths[exports.ParameterType.AUDIO]],
                  video: [...preloadPaths[exports.ParameterType.VIDEO]],
              };
          }
          cancelPreloads() {
              for (const request of this.preload_requests) {
                  request.onload = () => { };
                  request.onerror = () => { };
                  request.oncanplaythrough = () => { };
                  request.onabort = () => { };
              }
              this.preload_requests = [];
          }
          initializeMicrophoneRecorder(stream) {
              const recorder = new MediaRecorder(stream);
              this.microphone_recorder = recorder;
          }
          getMicrophoneRecorder() {
              return this.microphone_recorder;
          }
      }
  
      class SimulationAPI {
          dispatchEvent(event) {
              document.body.dispatchEvent(event);
          }
          /**
           * Dispatches a `keydown` event for the specified key
           * @param key Character code (`.key` property) for the key to press.
           */
          keyDown(key) {
              this.dispatchEvent(new KeyboardEvent("keydown", { key }));
          }
          /**
           * Dispatches a `keyup` event for the specified key
           * @param key Character code (`.key` property) for the key to press.
           */
          keyUp(key) {
              this.dispatchEvent(new KeyboardEvent("keyup", { key }));
          }
          /**
           * Dispatches a `keydown` and `keyup` event in sequence to simulate pressing a key.
           * @param key Character code (`.key` property) for the key to press.
           * @param delay Length of time to wait (ms) before executing action
           */
          pressKey(key, delay = 0) {
              if (delay > 0) {
                  setTimeout(() => {
                      this.keyDown(key);
                      this.keyUp(key);
                  }, delay);
              }
              else {
                  this.keyDown(key);
                  this.keyUp(key);
              }
          }
          /**
           * Dispatches `mousedown`, `mouseup`, and `click` events on the target element
           * @param target The element to click
           * @param delay Length of time to wait (ms) before executing action
           */
          clickTarget(target, delay = 0) {
              if (delay > 0) {
                  setTimeout(() => {
                      target.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
                      target.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
                      target.dispatchEvent(new MouseEvent("click", { bubbles: true }));
                  }, delay);
              }
              else {
                  target.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
                  target.dispatchEvent(new MouseEvent("mouseup", { bubbles: true }));
                  target.dispatchEvent(new MouseEvent("click", { bubbles: true }));
              }
          }
          /**
           * Sets the value of a target text input
           * @param target A text input element to fill in
           * @param text Text to input
           * @param delay Length of time to wait (ms) before executing action
           */
          fillTextInput(target, text, delay = 0) {
              if (delay > 0) {
                  setTimeout(() => {
                      target.value = text;
                  }, delay);
              }
              else {
                  target.value = text;
              }
          }
          /**
           * Picks a valid key from `choices`, taking into account jsPsych-specific
           * identifiers like "NO_KEYS" and "ALL_KEYS".
           * @param choices Which keys are valid.
           * @returns A key selected at random from the valid keys.
           */
          getValidKey(choices) {
              const possible_keys = [
                  "a",
                  "b",
                  "c",
                  "d",
                  "e",
                  "f",
                  "g",
                  "h",
                  "i",
                  "j",
                  "k",
                  "l",
                  "m",
                  "n",
                  "o",
                  "p",
                  "q",
                  "r",
                  "s",
                  "t",
                  "u",
                  "v",
                  "w",
                  "x",
                  "y",
                  "z",
                  "0",
                  "1",
                  "2",
                  "3",
                  "4",
                  "5",
                  "6",
                  "7",
                  "8",
                  "9",
                  " ",
              ];
              let key;
              if (choices == "NO_KEYS") {
                  key = null;
              }
              else if (choices == "ALL_KEYS") {
                  key = possible_keys[Math.floor(Math.random() * possible_keys.length)];
              }
              else {
                  const flat_choices = choices.flat();
                  key = flat_choices[Math.floor(Math.random() * flat_choices.length)];
              }
              return key;
          }
          mergeSimulationData(default_data, simulation_options) {
              // override any data with data from simulation object
              return Object.assign(Object.assign({}, default_data), simulation_options === null || simulation_options === void 0 ? void 0 : simulation_options.data);
          }
          ensureSimulationDataConsistency(trial, data) {
              // All RTs must be rounded
              if (data.rt) {
                  data.rt = Math.round(data.rt);
              }
              // If a trial_duration and rt exist, make sure that the RT is not longer than the trial.
              if (trial.trial_duration && data.rt && data.rt > trial.trial_duration) {
                  data.rt = null;
                  if (data.response) {
                      data.response = null;
                  }
                  if (data.correct) {
                      data.correct = false;
                  }
              }
              // If trial.choices is NO_KEYS make sure that response and RT are null
              if (trial.choices && trial.choices == "NO_KEYS") {
                  if (data.rt) {
                      data.rt = null;
                  }
                  if (data.response) {
                      data.response = null;
                  }
              }
              // If response is not allowed before stimulus display complete, ensure RT
              // is longer than display time.
              if (trial.allow_response_before_complete) {
                  if (trial.sequence_reps && trial.frame_time) {
                      const min_time = trial.sequence_reps * trial.frame_time * trial.stimuli.length;
                      if (data.rt < min_time) {
                          data.rt = null;
                          data.response = null;
                      }
                  }
              }
          }
      }
  
      class TimeoutAPI {
          constructor() {
              this.timeout_handlers = [];
          }
          setTimeout(callback, delay) {
              const handle = window.setTimeout(callback, delay);
              this.timeout_handlers.push(handle);
              return handle;
          }
          clearAllTimeouts() {
              for (const handler of this.timeout_handlers) {
                  clearTimeout(handler);
              }
              this.timeout_handlers = [];
          }
      }
  
      function createJointPluginAPIObject(jsPsych) {
          const settings = jsPsych.getInitSettings();
          return Object.assign({}, ...[
              new KeyboardListenerAPI(jsPsych.getDisplayContainerElement, settings.case_sensitive_responses, settings.minimum_valid_rt),
              new TimeoutAPI(),
              new MediaAPI(settings.use_webaudio, jsPsych.webaudio_context),
              new HardwareAPI(),
              new SimulationAPI(),
          ].map((object) => autoBind(object)));
      }
  
      var wordList = [
        // Borrowed from xkcd password generator which borrowed it from wherever
        "ability","able","aboard","about","above","accept","accident","according",
        "account","accurate","acres","across","act","action","active","activity",
        "actual","actually","add","addition","additional","adjective","adult","adventure",
        "advice","affect","afraid","after","afternoon","again","against","age",
        "ago","agree","ahead","aid","air","airplane","alike","alive",
        "all","allow","almost","alone","along","aloud","alphabet","already",
        "also","although","am","among","amount","ancient","angle","angry",
        "animal","announced","another","answer","ants","any","anybody","anyone",
        "anything","anyway","anywhere","apart","apartment","appearance","apple","applied",
        "appropriate","are","area","arm","army","around","arrange","arrangement",
        "arrive","arrow","art","article","as","aside","ask","asleep",
        "at","ate","atmosphere","atom","atomic","attached","attack","attempt",
        "attention","audience","author","automobile","available","average","avoid","aware",
        "away","baby","back","bad","badly","bag","balance","ball",
        "balloon","band","bank","bar","bare","bark","barn","base",
        "baseball","basic","basis","basket","bat","battle","be","bean",
        "bear","beat","beautiful","beauty","became","because","become","becoming",
        "bee","been","before","began","beginning","begun","behavior","behind",
        "being","believed","bell","belong","below","belt","bend","beneath",
        "bent","beside","best","bet","better","between","beyond","bicycle",
        "bigger","biggest","bill","birds","birth","birthday","bit","bite",
        "black","blank","blanket","blew","blind","block","blood","blow",
        "blue","board","boat","body","bone","book","border","born",
        "both","bottle","bottom","bound","bow","bowl","box","boy",
        "brain","branch","brass","brave","bread","break","breakfast","breath",
        "breathe","breathing","breeze","brick","bridge","brief","bright","bring",
        "broad","broke","broken","brother","brought","brown","brush","buffalo",
        "build","building","built","buried","burn","burst","bus","bush",
        "business","busy","but","butter","buy","by","cabin","cage",
        "cake","call","calm","came","camera","camp","can","canal",
        "cannot","cap","capital","captain","captured","car","carbon","card",
        "care","careful","carefully","carried","carry","case","cast","castle",
        "cat","catch","cattle","caught","cause","cave","cell","cent",
        "center","central","century","certain","certainly","chain","chair","chamber",
        "chance","change","changing","chapter","character","characteristic","charge","chart",
        "check","cheese","chemical","chest","chicken","chief","child","children",
        "choice","choose","chose","chosen","church","circle","circus","citizen",
        "city","class","classroom","claws","clay","clean","clear","clearly",
        "climate","climb","clock","close","closely","closer","cloth","clothes",
        "clothing","cloud","club","coach","coal","coast","coat","coffee",
        "cold","collect","college","colony","color","column","combination","combine",
        "come","comfortable","coming","command","common","community","company","compare",
        "compass","complete","completely","complex","composed","composition","compound","concerned",
        "condition","congress","connected","consider","consist","consonant","constantly","construction",
        "contain","continent","continued","contrast","control","conversation","cook","cookies",
        "cool","copper","copy","corn","corner","correct","correctly","cost",
        "cotton","could","count","country","couple","courage","course","court",
        "cover","cow","cowboy","crack","cream","create","creature","crew",
        "crop","cross","crowd","cry","cup","curious","current","curve",
        "customs","cut","cutting","daily","damage","dance","danger","dangerous",
        "dark","darkness","date","daughter","dawn","day","dead","deal",
        "dear","death","decide","declared","deep","deeply","deer","definition",
        "degree","depend","depth","describe","desert","design","desk","detail",
        "determine","develop","development","diagram","diameter","did","die","differ",
        "difference","different","difficult","difficulty","dig","dinner","direct","direction",
        "directly","dirt","dirty","disappear","discover","discovery","discuss","discussion",
        "disease","dish","distance","distant","divide","division","do","doctor",
        "does","dog","doing","doll","dollar","done","donkey","door",
        "dot","double","doubt","down","dozen","draw","drawn","dream",
        "dress","drew","dried","drink","drive","driven","driver","driving",
        "drop","dropped","drove","dry","duck","due","dug","dull",
        "during","dust","duty","each","eager","ear","earlier","early",
        "earn","earth","easier","easily","east","easy","eat","eaten",
        "edge","education","effect","effort","egg","eight","either","electric",
        "electricity","element","elephant","eleven","else","empty","end","enemy",
        "energy","engine","engineer","enjoy","enough","enter","entire","entirely",
        "environment","equal","equally","equator","equipment","escape","especially","essential",
        "establish","even","evening","event","eventually","ever","every","everybody",
        "everyone","everything","everywhere","evidence","exact","exactly","examine","example",
        "excellent","except","exchange","excited","excitement","exciting","exclaimed","exercise",
        "exist","expect","experience","experiment","explain","explanation","explore","express",
        "expression","extra","eye","face","facing","fact","factor","factory",
        "failed","fair","fairly","fall","fallen","familiar","family","famous",
        "far","farm","farmer","farther","fast","fastened","faster","fat",
        "father","favorite","fear","feathers","feature","fed","feed","feel",
        "feet","fell","fellow","felt","fence","few","fewer","field",
        "fierce","fifteen","fifth","fifty","fight","fighting","figure","fill",
        "film","final","finally","find","fine","finest","finger","finish",
        "fire","fireplace","firm","first","fish","five","fix","flag",
        "flame","flat","flew","flies","flight","floating","floor","flow",
        "flower","fly","fog","folks","follow","food","foot","football",
        "for","force","foreign","forest","forget","forgot","forgotten","form",
        "former","fort","forth","forty","forward","fought","found","four",
        "fourth","fox","frame","free","freedom","frequently","fresh","friend",
        "friendly","frighten","frog","from","front","frozen","fruit","fuel",
        "full","fully","fun","function","funny","fur","furniture","further",
        "future","gain","game","garage","garden","gas","gasoline","gate",
        "gather","gave","general","generally","gentle","gently","get","getting",
        "giant","gift","girl","give","given","giving","glad","glass",
        "globe","go","goes","gold","golden","gone","good","goose",
        "got","government","grabbed","grade","gradually","grain","grandfather","grandmother",
        "graph","grass","gravity","gray","great","greater","greatest","greatly",
        "green","grew","ground","group","grow","grown","growth","guard",
        "guess","guide","gulf","gun","habit","had","hair","half",
        "halfway","hall","hand","handle","handsome","hang","happen","happened",
        "happily","happy","harbor","hard","harder","hardly","has","hat",
        "have","having","hay","he","headed","heading","health","heard",
        "hearing","heart","heat","heavy","height","held","hello","help",
        "helpful","her","herd","here","herself","hidden","hide","high",
        "higher","highest","highway","hill","him","himself","his","history",
        "hit","hold","hole","hollow","home","honor","hope","horn",
        "horse","hospital","hot","hour","house","how","however","huge",
        "human","hundred","hung","hungry","hunt","hunter","hurried","hurry",
        "hurt","husband","ice","idea","identity","if","ill","image",
        "imagine","immediately","importance","important","impossible","improve","in","inch",
        "include","including","income","increase","indeed","independent","indicate","individual",
        "industrial","industry","influence","information","inside","instance","instant","instead",
        "instrument","interest","interior","into","introduced","invented","involved","iron",
        "is","island","it","its","itself","jack","jar","jet",
        "job","join","joined","journey","joy","judge","jump","jungle",
        "just","keep","kept","key","kids","kill","kind","kitchen",
        "knew","knife","know","knowledge","known","label","labor","lack",
        "lady","laid","lake","lamp","land","language","large","larger",
        "largest","last","late","later","laugh","law","lay","layers",
        "lead","leader","leaf","learn","least","leather","leave","leaving",
        "led","left","leg","length","lesson","let","letter","level",
        "library","lie","life","lift","light","like","likely","limited",
        "line","lion","lips","liquid","list","listen","little","live",
        "living","load","local","locate","location","log","lonely","long",
        "longer","look","loose","lose","loss","lost","lot","loud",
        "love","lovely","low","lower","luck","lucky","lunch","lungs",
        "lying","machine","machinery","mad","made","magic","magnet","mail",
        "main","mainly","major","make","making","man","managed","manner",
        "manufacturing","many","map","mark","market","married","mass","massage",
        "master","material","mathematics","matter","may","maybe","me","meal",
        "mean","means","meant","measure","meat","medicine","meet","melted",
        "member","memory","men","mental","merely","met","metal","method",
        "mice","middle","might","mighty","mile","military","milk","mill",
        "mind","mine","minerals","minute","mirror","missing","mission","mistake",
        "mix","mixture","model","modern","molecular","moment","money","monkey",
        "month","mood","moon","more","morning","most","mostly","mother",
        "motion","motor","mountain","mouse","mouth","move","movement","movie",
        "moving","mud","muscle","music","musical","must","my","myself",
        "mysterious","nails","name","nation","national","native","natural","naturally",
        "nature","near","nearby","nearer","nearest","nearly","necessary","neck",
        "needed","needle","needs","negative","neighbor","neighborhood","nervous","nest",
        "never","new","news","newspaper","next","nice","night","nine",
        "no","nobody","nodded","noise","none","noon","nor","north",
        "nose","not","note","noted","nothing","notice","noun","now",
        "number","numeral","nuts","object","observe","obtain","occasionally","occur",
        "ocean","of","off","offer","office","officer","official","oil",
        "old","older","oldest","on","once","one","only","onto",
        "open","operation","opinion","opportunity","opposite","or","orange","orbit",
        "order","ordinary","organization","organized","origin","original","other","ought",
        "our","ourselves","out","outer","outline","outside","over","own",
        "owner","oxygen","pack","package","page","paid","pain","paint",
        "pair","palace","pale","pan","paper","paragraph","parallel","parent",
        "park","part","particles","particular","particularly","partly","parts","party",
        "pass","passage","past","path","pattern","pay","peace","pen",
        "pencil","people","per","percent","perfect","perfectly","perhaps","period",
        "person","personal","pet","phrase","physical","piano","pick","picture",
        "pictured","pie","piece","pig","pile","pilot","pine","pink",
        "pipe","pitch","place","plain","plan","plane","planet","planned",
        "planning","plant","plastic","plate","plates","play","pleasant","please",
        "pleasure","plenty","plural","plus","pocket","poem","poet","poetry",
        "point","pole","police","policeman","political","pond","pony","pool",
        "poor","popular","population","porch","port","position","positive","possible",
        "possibly","post","pot","potatoes","pound","pour","powder","power",
        "powerful","practical","practice","prepare","present","president","press","pressure",
        "pretty","prevent","previous","price","pride","primitive","principal","principle",
        "printed","private","prize","probably","problem","process","produce","product",
        "production","program","progress","promised","proper","properly","property","protection",
        "proud","prove","provide","public","pull","pupil","pure","purple",
        "purpose","push","put","putting","quarter","queen","question","quick",
        "quickly","quiet","quietly","quite","rabbit","race","radio","railroad",
        "rain","raise","ran","ranch","range","rapidly","rate","rather",
        "raw","rays","reach","read","reader","ready","real","realize",
        "rear","reason","recall","receive","recent","recently","recognize","record",
        "red","refer","refused","region","regular","related","relationship","religious",
        "remain","remarkable","remember","remove","repeat","replace","replied","report",
        "represent","require","research","respect","rest","result","return","review",
        "rhyme","rhythm","rice","rich","ride","riding","right","ring",
        "rise","rising","river","road","roar","rock","rocket","rocky",
        "rod","roll","roof","room","root","rope","rose","rough",
        "round","route","row","rubbed","rubber","rule","ruler","run",
        "running","rush","sad","saddle","safe","safety","said","sail",
        "sale","salmon","salt","same","sand","sang","sat","satellites",
        "satisfied","save","saved","saw","say","scale","scared","scene",
        "school","science","scientific","scientist","score","screen","sea","search",
        "season","seat","second","secret","section","see","seed","seeing",
        "seems","seen","seldom","select","selection","sell","send","sense",
        "sent","sentence","separate","series","serious","serve","service","sets",
        "setting","settle","settlers","seven","several","shade","shadow","shake",
        "shaking","shall","shallow","shape","share","sharp","she","sheep",
        "sheet","shelf","shells","shelter","shine","shinning","ship","shirt",
        "shoe","shoot","shop","shore","short","shorter","shot","should",
        "shoulder","shout","show","shown","shut","sick","sides","sight",
        "sign","signal","silence","silent","silk","silly","silver","similar",
        "simple","simplest","simply","since","sing","single","sink","sister",
        "sit","sitting","situation","six","size","skill","skin","sky",
        "slabs","slave","sleep","slept","slide","slight","slightly","slip",
        "slipped","slope","slow","slowly","small","smaller","smallest","smell",
        "smile","smoke","smooth","snake","snow","so","soap","social",
        "society","soft","softly","soil","solar","sold","soldier","solid",
        "solution","solve","some","somebody","somehow","someone","something","sometime",
        "somewhere","son","song","soon","sort","sound","source","south",
        "southern","space","speak","special","species","specific","speech","speed",
        "spell","spend","spent","spider","spin","spirit","spite","split",
        "spoken","sport","spread","spring","square","stage","stairs","stand",
        "standard","star","stared","start","state","statement","station","stay",
        "steady","steam","steel","steep","stems","step","stepped","stick",
        "stiff","still","stock","stomach","stone","stood","stop","stopped",
        "store","storm","story","stove","straight","strange","stranger","straw",
        "stream","street","strength","stretch","strike","string","strip","strong",
        "stronger","struck","structure","struggle","stuck","student","studied","studying",
        "subject","substance","success","successful","such","sudden","suddenly","sugar",
        "suggest","suit","sum","summer","sun","sunlight","supper","supply",
        "support","suppose","sure","surface","surprise","surrounded","swam","sweet",
        "swept","swim","swimming","swing","swung","syllable","symbol","system",
        "table","tail","take","taken","tales","talk","tall","tank",
        "tape","task","taste","taught","tax","tea","teach","teacher",
        "team","tears","teeth","telephone","television","tell","temperature","ten",
        "tent","term","terrible","test","than","thank","that","thee",
        "them","themselves","then","theory","there","therefore","these","they",
        "thick","thin","thing","think","third","thirty","this","those",
        "thou","though","thought","thousand","thread","three","threw","throat",
        "through","throughout","throw","thrown","thumb","thus","thy","tide",
        "tie","tight","tightly","till","time","tin","tiny","tip",
        "tired","title","to","tobacco","today","together","told","tomorrow",
        "tone","tongue","tonight","too","took","tool","top","topic",
        "torn","total","touch","toward","tower","town","toy","trace",
        "track","trade","traffic","trail","train","transportation","trap","travel",
        "treated","tree","triangle","tribe","trick","tried","trip","troops",
        "tropical","trouble","truck","trunk","truth","try","tube","tune",
        "turn","twelve","twenty","twice","two","type","typical","uncle",
        "under","underline","understanding","unhappy","union","unit","universe","unknown",
        "unless","until","unusual","up","upon","upper","upward","us",
        "use","useful","using","usual","usually","valley","valuable","value",
        "vapor","variety","various","vast","vegetable","verb","vertical","very",
        "vessels","victory","view","village","visit","visitor","voice","volume",
        "vote","vowel","voyage","wagon","wait","walk","wall","want",
        "war","warm","warn","was","wash","waste","watch","water",
        "wave","way","we","weak","wealth","wear","weather","week",
        "weigh","weight","welcome","well","went","were","west","western",
        "wet","whale","what","whatever","wheat","wheel","when","whenever",
        "where","wherever","whether","which","while","whispered","whistle","white",
        "who","whole","whom","whose","why","wide","widely","wife",
        "wild","will","willing","win","wind","window","wing","winter",
        "wire","wise","wish","with","within","without","wolf","women",
        "won","wonder","wonderful","wood","wooden","wool","word","wore",
        "work","worker","world","worried","worry","worse","worth","would",
        "wrapped","write","writer","writing","written","wrong","wrote","yard",
        "year","yellow","yes","yesterday","yet","you","young","younger",
        "your","yourself","youth","zero","zebra","zipper","zoo","zulu"
      ];
  
      function words(options) {
  
        function word() {
          if (options && options.maxLength > 1) {
            return generateWordWithMaxLength();
          } else {
            return generateRandomWord();
          }
        }
  
        function generateWordWithMaxLength() {
          var rightSize = false;
          var wordUsed;
          while (!rightSize) {  
            wordUsed = generateRandomWord();
            if(wordUsed.length <= options.maxLength) {
              rightSize = true;
            }
  
          }
          return wordUsed;
        }
  
        function generateRandomWord() {
          return wordList[randInt(wordList.length)];
        }
  
        function randInt(lessThan) {
          return Math.floor(Math.random() * lessThan);
        }
  
        // No arguments = generate one word
        if (typeof(options) === 'undefined') {
          return word();
        }
  
        // Just a number = return that many words
        if (typeof(options) === 'number') {
          options = { exactly: options };
        }
  
        // options supported: exactly, min, max, join
        if (options.exactly) {
          options.min = options.exactly;
          options.max = options.exactly;
        }
        
        // not a number = one word par string
        if (typeof(options.wordsPerString) !== 'number') {
          options.wordsPerString = 1;
        }
  
        //not a function = returns the raw word
        if (typeof(options.formatter) !== 'function') {
          options.formatter = (word) => word;
        }
  
        //not a string = separator is a space
        if (typeof(options.separator) !== 'string') {
          options.separator = ' ';
        }
  
        var total = options.min + randInt(options.max + 1 - options.min);
        var results = [];
        var token = '';
        var relativeIndex = 0;
  
        for (var i = 0; (i < total * options.wordsPerString); i++) {
          if (relativeIndex === options.wordsPerString - 1) {
            token += options.formatter(word(), relativeIndex);
          }
          else {
            token += options.formatter(word(), relativeIndex) + options.separator;
          }
          relativeIndex++;
          if ((i + 1) % options.wordsPerString === 0) {
            results.push(token);
            token = ''; 
            relativeIndex = 0;
          }
         
        }
        if (typeof options.join === 'string') {
          results = results.join(options.join);
        }
  
        return results;
      }
  
      var randomWords$1 = words;
      // Export the word list as it is often useful
      words.wordList = wordList;
  
      var alea = {exports: {}};
  
      (function (module) {
      // A port of an algorithm by Johannes Baagøe <baagoe@baagoe.com>, 2010
      // http://baagoe.com/en/RandomMusings/javascript/
      // https://github.com/nquinlan/better-random-numbers-for-javascript-mirror
      // Original work is under MIT license -
  
      // Copyright (C) 2010 by Johannes Baagøe <baagoe@baagoe.org>
      //
      // Permission is hereby granted, free of charge, to any person obtaining a copy
      // of this software and associated documentation files (the "Software"), to deal
      // in the Software without restriction, including without limitation the rights
      // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      // copies of the Software, and to permit persons to whom the Software is
      // furnished to do so, subject to the following conditions:
      //
      // The above copyright notice and this permission notice shall be included in
      // all copies or substantial portions of the Software.
      //
      // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      // THE SOFTWARE.
  
  
  
      (function(global, module, define) {
  
      function Alea(seed) {
        var me = this, mash = Mash();
  
        me.next = function() {
          var t = 2091639 * me.s0 + me.c * 2.3283064365386963e-10; // 2^-32
          me.s0 = me.s1;
          me.s1 = me.s2;
          return me.s2 = t - (me.c = t | 0);
        };
  
        // Apply the seeding algorithm from Baagoe.
        me.c = 1;
        me.s0 = mash(' ');
        me.s1 = mash(' ');
        me.s2 = mash(' ');
        me.s0 -= mash(seed);
        if (me.s0 < 0) { me.s0 += 1; }
        me.s1 -= mash(seed);
        if (me.s1 < 0) { me.s1 += 1; }
        me.s2 -= mash(seed);
        if (me.s2 < 0) { me.s2 += 1; }
        mash = null;
      }
  
      function copy(f, t) {
        t.c = f.c;
        t.s0 = f.s0;
        t.s1 = f.s1;
        t.s2 = f.s2;
        return t;
      }
  
      function impl(seed, opts) {
        var xg = new Alea(seed),
            state = opts && opts.state,
            prng = xg.next;
        prng.int32 = function() { return (xg.next() * 0x100000000) | 0; };
        prng.double = function() {
          return prng() + (prng() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
        };
        prng.quick = prng;
        if (state) {
          if (typeof(state) == 'object') copy(state, xg);
          prng.state = function() { return copy(xg, {}); };
        }
        return prng;
      }
  
      function Mash() {
        var n = 0xefc8249d;
  
        var mash = function(data) {
          data = String(data);
          for (var i = 0; i < data.length; i++) {
            n += data.charCodeAt(i);
            var h = 0.02519603282416938 * n;
            n = h >>> 0;
            h -= n;
            h *= n;
            n = h >>> 0;
            h -= n;
            n += h * 0x100000000; // 2^32
          }
          return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
        };
  
        return mash;
      }
  
  
      if (module && module.exports) {
        module.exports = impl;
      } else if (define && define.amd) {
        define(function() { return impl; });
      } else {
        this.alea = impl;
      }
  
      })(
        commonjsGlobal,
        module,    // present in node.js
        (typeof undefined) == 'function'    // present with an AMD loader
      );
      }(alea));
  
      var seedrandom = alea.exports;
  
      /**
       * Uses the `seedrandom` package to replace Math.random() with a seedable PRNG.
       *
       * @param seed An optional seed. If none is given, a random seed will be generated.
       * @returns The seed value.
       */
      function setSeed(seed = Math.random().toString()) {
          Math.random = seedrandom(seed);
          return seed;
      }
      function repeat(array, repetitions, unpack = false) {
          const arr_isArray = Array.isArray(array);
          const rep_isArray = Array.isArray(repetitions);
          // if array is not an array, then we just repeat the item
          if (!arr_isArray) {
              if (!rep_isArray) {
                  array = [array];
                  repetitions = [repetitions];
              }
              else {
                  repetitions = [repetitions[0]];
                  console.log("Unclear parameters given to randomization.repeat. Multiple set sizes specified, but only one item exists to sample. Proceeding using the first set size.");
              }
          }
          else {
              // if repetitions is not an array, but array is, then we
              // repeat repetitions for each entry in array
              if (!rep_isArray) {
                  let reps = [];
                  for (let i = 0; i < array.length; i++) {
                      reps.push(repetitions);
                  }
                  repetitions = reps;
              }
              else {
                  if (array.length != repetitions.length) {
                      console.warn("Unclear parameters given to randomization.repeat. Items and repetitions are unequal lengths. Behavior may not be as expected.");
                      // throw warning if repetitions is too short, use first rep ONLY.
                      if (repetitions.length < array.length) {
                          let reps = [];
                          for (let i = 0; i < array.length; i++) {
                              reps.push(repetitions);
                          }
                          repetitions = reps;
                      }
                      else {
                          // throw warning if too long, and then use the first N
                          repetitions = repetitions.slice(0, array.length);
                      }
                  }
              }
          }
          // should be clear at this point to assume that array and repetitions are arrays with == length
          let allsamples = [];
          for (let i = 0; i < array.length; i++) {
              for (let j = 0; j < repetitions[i]; j++) {
                  if (array[i] == null || typeof array[i] != "object") {
                      allsamples.push(array[i]);
                  }
                  else {
                      allsamples.push(Object.assign({}, array[i]));
                  }
              }
          }
          let out = shuffle(allsamples);
          if (unpack) {
              out = unpackArray(out);
          }
          return out;
      }
      function shuffle(array) {
          if (!Array.isArray(array)) {
              console.error("Argument to shuffle() must be an array.");
          }
          const copy_array = array.slice(0);
          let m = copy_array.length, t, i;
          // While there remain elements to shuffle…
          while (m) {
              // Pick a remaining element…
              i = Math.floor(Math.random() * m--);
              // And swap it with the current element.
              t = copy_array[m];
              copy_array[m] = copy_array[i];
              copy_array[i] = t;
          }
          return copy_array;
      }
      function shuffleNoRepeats(arr, equalityTest) {
          if (!Array.isArray(arr)) {
              console.error("First argument to shuffleNoRepeats() must be an array.");
          }
          if (typeof equalityTest !== "undefined" && typeof equalityTest !== "function") {
              console.error("Second argument to shuffleNoRepeats() must be a function.");
          }
          // define a default equalityTest
          if (typeof equalityTest == "undefined") {
              equalityTest = function (a, b) {
                  if (a === b) {
                      return true;
                  }
                  else {
                      return false;
                  }
              };
          }
          const random_shuffle = shuffle(arr);
          for (let i = 0; i < random_shuffle.length - 1; i++) {
              if (equalityTest(random_shuffle[i], random_shuffle[i + 1])) {
                  // neighbors are equal, pick a new random neighbor to swap (not the first or last element, to avoid edge cases)
                  let random_pick = Math.floor(Math.random() * (random_shuffle.length - 2)) + 1;
                  // test to make sure the new neighbor isn't equal to the old one
                  while (equalityTest(random_shuffle[i + 1], random_shuffle[random_pick]) ||
                      equalityTest(random_shuffle[i + 1], random_shuffle[random_pick + 1]) ||
                      equalityTest(random_shuffle[i + 1], random_shuffle[random_pick - 1])) {
                      random_pick = Math.floor(Math.random() * (random_shuffle.length - 2)) + 1;
                  }
                  const new_neighbor = random_shuffle[random_pick];
                  random_shuffle[random_pick] = random_shuffle[i + 1];
                  random_shuffle[i + 1] = new_neighbor;
              }
          }
          return random_shuffle;
      }
      function shuffleAlternateGroups(arr_groups, random_group_order = false) {
          const n_groups = arr_groups.length;
          if (n_groups == 1) {
              console.warn("shuffleAlternateGroups() was called with only one group. Defaulting to simple shuffle.");
              return shuffle(arr_groups[0]);
          }
          let group_order = [];
          for (let i = 0; i < n_groups; i++) {
              group_order.push(i);
          }
          if (random_group_order) {
              group_order = shuffle(group_order);
          }
          const randomized_groups = [];
          let min_length = null;
          for (let i = 0; i < n_groups; i++) {
              min_length =
                  min_length === null ? arr_groups[i].length : Math.min(min_length, arr_groups[i].length);
              randomized_groups.push(shuffle(arr_groups[i]));
          }
          const out = [];
          for (let i = 0; i < min_length; i++) {
              for (let j = 0; j < group_order.length; j++) {
                  out.push(randomized_groups[group_order[j]][i]);
              }
          }
          return out;
      }
      function sampleWithoutReplacement(arr, size) {
          if (!Array.isArray(arr)) {
              console.error("First argument to sampleWithoutReplacement() must be an array");
          }
          if (size > arr.length) {
              console.error("Cannot take a sample larger than the size of the set of items to sample.");
          }
          return shuffle(arr).slice(0, size);
      }
      function sampleWithReplacement(arr, size, weights) {
          if (!Array.isArray(arr)) {
              console.error("First argument to sampleWithReplacement() must be an array");
          }
          const normalized_weights = [];
          if (typeof weights !== "undefined") {
              if (weights.length !== arr.length) {
                  console.error("The length of the weights array must equal the length of the array " +
                      "to be sampled from.");
              }
              let weight_sum = 0;
              for (const weight of weights) {
                  weight_sum += weight;
              }
              for (const weight of weights) {
                  normalized_weights.push(weight / weight_sum);
              }
          }
          else {
              for (let i = 0; i < arr.length; i++) {
                  normalized_weights.push(1 / arr.length);
              }
          }
          const cumulative_weights = [normalized_weights[0]];
          for (let i = 1; i < normalized_weights.length; i++) {
              cumulative_weights.push(normalized_weights[i] + cumulative_weights[i - 1]);
          }
          const samp = [];
          for (let i = 0; i < size; i++) {
              const rnd = Math.random();
              let index = 0;
              while (rnd > cumulative_weights[index]) {
                  index++;
              }
              samp.push(arr[index]);
          }
          return samp;
      }
      function factorial(factors, repetitions = 1, unpack = false) {
          let design = [{}];
          for (const [factorName, factor] of Object.entries(factors)) {
              const new_design = [];
              for (const level of factor) {
                  for (const cell of design) {
                      new_design.push(Object.assign(Object.assign({}, cell), { [factorName]: level }));
                  }
              }
              design = new_design;
          }
          return repeat(design, repetitions, unpack);
      }
      function randomID(length = 32) {
          let result = "";
          const chars = "0123456789abcdefghjklmnopqrstuvwxyz";
          for (let i = 0; i < length; i++) {
              result += chars[Math.floor(Math.random() * chars.length)];
          }
          return result;
      }
      /**
       * Generate a random integer from `lower` to `upper`, inclusive of both end points.
       * @param lower The lowest value it is possible to generate
       * @param upper The highest value it is possible to generate
       * @returns A random integer
       */
      function randomInt(lower, upper) {
          if (upper < lower) {
              throw new Error("Upper boundary must be less than or equal to lower boundary");
          }
          return lower + Math.floor(Math.random() * (upper - lower + 1));
      }
      /**
       * Generates a random sample from a Bernoulli distribution.
       * @param p The probability of sampling 1.
       * @returns 0, with probability 1-p, or 1, with probability p.
       */
      function sampleBernoulli(p) {
          return Math.random() <= p ? 1 : 0;
      }
      function sampleNormal(mean, standard_deviation) {
          return randn_bm() * standard_deviation + mean;
      }
      function sampleExponential(rate) {
          return -Math.log(Math.random()) / rate;
      }
      function sampleExGaussian(mean, standard_deviation, rate, positive = false) {
          let s = sampleNormal(mean, standard_deviation) + sampleExponential(rate);
          if (positive) {
              while (s <= 0) {
                  s = sampleNormal(mean, standard_deviation) + sampleExponential(rate);
              }
          }
          return s;
      }
      /**
       * Generate one or more random words.
       *
       * This is a wrapper function for the {@link https://www.npmjs.com/package/random-words `random-words` npm package}.
       *
       * @param opts An object with optional properties `min`, `max`, `exactly`,
       * `join`, `maxLength`, `wordsPerString`, `separator`, and `formatter`.
       *
       * @returns An array of words or a single string, depending on parameter choices.
       */
      function randomWords(opts) {
          return randomWords$1(opts);
      }
      // Box-Muller transformation for a random sample from normal distribution with mean = 0, std = 1
      // https://stackoverflow.com/a/36481059/3726673
      function randn_bm() {
          var u = 0, v = 0;
          while (u === 0)
              u = Math.random(); //Converting [0,1) to (0,1)
          while (v === 0)
              v = Math.random();
          return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
      }
      function unpackArray(array) {
          const out = {};
          for (const x of array) {
              for (const key of Object.keys(x)) {
                  if (typeof out[key] === "undefined") {
                      out[key] = [];
                  }
                  out[key].push(x[key]);
              }
          }
          return out;
      }
  
      var randomization = /*#__PURE__*/Object.freeze({
          __proto__: null,
          setSeed: setSeed,
          repeat: repeat,
          shuffle: shuffle,
          shuffleNoRepeats: shuffleNoRepeats,
          shuffleAlternateGroups: shuffleAlternateGroups,
          sampleWithoutReplacement: sampleWithoutReplacement,
          sampleWithReplacement: sampleWithReplacement,
          factorial: factorial,
          randomID: randomID,
          randomInt: randomInt,
          sampleBernoulli: sampleBernoulli,
          sampleNormal: sampleNormal,
          sampleExponential: sampleExponential,
          sampleExGaussian: sampleExGaussian,
          randomWords: randomWords
      });
  
      /**
       * Gets information about the Mechanical Turk Environment, HIT, Assignment, and Worker
       * by parsing the URL variables that Mechanical Turk generates.
       * @returns An object containing information about the Mechanical Turk Environment, HIT, Assignment, and Worker.
       */
      function turkInfo() {
          const turk = {
              previewMode: false,
              outsideTurk: false,
              hitId: "INVALID_URL_PARAMETER",
              assignmentId: "INVALID_URL_PARAMETER",
              workerId: "INVALID_URL_PARAMETER",
              turkSubmitTo: "INVALID_URL_PARAMETER",
          };
          const param = function (url, name) {
              name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
              const regexS = "[\\?&]" + name + "=([^&#]*)";
              const regex = new RegExp(regexS);
              const results = regex.exec(url);
              return results == null ? "" : results[1];
          };
          const src = param(window.location.href, "assignmentId")
              ? window.location.href
              : document.referrer;
          const keys = ["assignmentId", "hitId", "workerId", "turkSubmitTo"];
          keys.map(function (key) {
              turk[key] = unescape(param(src, key));
          });
          turk.previewMode = turk.assignmentId == "ASSIGNMENT_ID_NOT_AVAILABLE";
          turk.outsideTurk =
              !turk.previewMode && turk.hitId === "" && turk.assignmentId == "" && turk.workerId == "";
          return turk;
      }
      /**
       * Send data to Mechnical Turk for storage.
       * @param data An object containing `key:value` pairs to send to Mechanical Turk. Values
       * cannot contain nested objects, arrays, or functions.
       * @returns Nothing
       */
      function submitToTurk(data) {
          const turk = turkInfo();
          const assignmentId = turk.assignmentId;
          const turkSubmitTo = turk.turkSubmitTo;
          if (!assignmentId || !turkSubmitTo)
              return;
          const form = document.createElement("form");
          form.method = "POST";
          form.action = turkSubmitTo + "/mturk/externalSubmit?assignmentId=" + assignmentId;
          for (const key in data) {
              if (data.hasOwnProperty(key)) {
                  const hiddenField = document.createElement("input");
                  hiddenField.type = "hidden";
                  hiddenField.name = key;
                  hiddenField.id = key;
                  hiddenField.value = data[key];
                  form.appendChild(hiddenField);
              }
          }
          document.body.appendChild(form);
          form.submit();
      }
  
      var turk = /*#__PURE__*/Object.freeze({
          __proto__: null,
          turkInfo: turkInfo,
          submitToTurk: submitToTurk
      });
  
      class TimelineNode {
          // constructor
          constructor(jsPsych, parameters, parent, relativeID) {
              this.jsPsych = jsPsych;
              // track progress through the node
              this.progress = {
                  current_location: -1,
                  current_variable_set: 0,
                  current_repetition: 0,
                  current_iteration: 0,
                  done: false,
              };
              // store a link to the parent of this node
              this.parent_node = parent;
              // create the ID for this node
              this.relative_id = typeof parent === "undefined" ? 0 : relativeID;
              // check if there is a timeline parameter
              // if there is, then this node has its own timeline
              if (typeof parameters.timeline !== "undefined") {
                  // create timeline properties
                  this.timeline_parameters = {
                      timeline: [],
                      loop_function: parameters.loop_function,
                      conditional_function: parameters.conditional_function,
                      sample: parameters.sample,
                      randomize_order: typeof parameters.randomize_order == "undefined" ? false : parameters.randomize_order,
                      repetitions: typeof parameters.repetitions == "undefined" ? 1 : parameters.repetitions,
                      timeline_variables: typeof parameters.timeline_variables == "undefined"
                          ? [{}]
                          : parameters.timeline_variables,
                      on_timeline_finish: parameters.on_timeline_finish,
                      on_timeline_start: parameters.on_timeline_start,
                  };
                  this.setTimelineVariablesOrder();
                  // extract all of the node level data and parameters
                  // but remove all of the timeline-level specific information
                  // since this will be used to copy things down hierarchically
                  var node_data = Object.assign({}, parameters);
                  delete node_data.timeline;
                  delete node_data.conditional_function;
                  delete node_data.loop_function;
                  delete node_data.randomize_order;
                  delete node_data.repetitions;
                  delete node_data.timeline_variables;
                  delete node_data.sample;
                  delete node_data.on_timeline_start;
                  delete node_data.on_timeline_finish;
                  this.node_trial_data = node_data; // store for later...
                  // create a TimelineNode for each element in the timeline
                  for (var i = 0; i < parameters.timeline.length; i++) {
                      // merge parameters
                      var merged_parameters = Object.assign({}, node_data, parameters.timeline[i]);
                      // merge any data from the parent node into child nodes
                      if (typeof node_data.data == "object" && typeof parameters.timeline[i].data == "object") {
                          var merged_data = Object.assign({}, node_data.data, parameters.timeline[i].data);
                          merged_parameters.data = merged_data;
                      }
                      this.timeline_parameters.timeline.push(new TimelineNode(this.jsPsych, merged_parameters, this, i));
                  }
              }
              // if there is no timeline parameter, then this node is a trial node
              else {
                  // check to see if a valid trial type is defined
                  if (typeof parameters.type === "undefined") {
                      console.error('Trial level node is missing the "type" parameter. The parameters for the node are: ' +
                          JSON.stringify(parameters));
                  }
                  // create a deep copy of the parameters for the trial
                  this.trial_parameters = Object.assign({}, parameters);
              }
          }
          // recursively get the next trial to run.
          // if this node is a leaf (trial), then return the trial.
          // otherwise, recursively find the next trial in the child timeline.
          trial() {
              if (typeof this.timeline_parameters == "undefined") {
                  // returns a clone of the trial_parameters to
                  // protect functions.
                  return deepCopy(this.trial_parameters);
              }
              else {
                  if (this.progress.current_location >= this.timeline_parameters.timeline.length) {
                      return null;
                  }
                  else {
                      return this.timeline_parameters.timeline[this.progress.current_location].trial();
                  }
              }
          }
          markCurrentTrialComplete() {
              if (typeof this.timeline_parameters === "undefined") {
                  this.progress.done = true;
              }
              else {
                  this.timeline_parameters.timeline[this.progress.current_location].markCurrentTrialComplete();
              }
          }
          nextRepetiton() {
              this.setTimelineVariablesOrder();
              this.progress.current_location = -1;
              this.progress.current_variable_set = 0;
              this.progress.current_repetition++;
              for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
                  this.timeline_parameters.timeline[i].reset();
              }
          }
          // set the order for going through the timeline variables array
          setTimelineVariablesOrder() {
              const timeline_parameters = this.timeline_parameters;
              // check to make sure this node has variables
              if (typeof timeline_parameters === "undefined" ||
                  typeof timeline_parameters.timeline_variables === "undefined") {
                  return;
              }
              var order = [];
              for (var i = 0; i < timeline_parameters.timeline_variables.length; i++) {
                  order.push(i);
              }
              if (typeof timeline_parameters.sample !== "undefined") {
                  if (timeline_parameters.sample.type == "custom") {
                      order = timeline_parameters.sample.fn(order);
                  }
                  else if (timeline_parameters.sample.type == "with-replacement") {
                      order = sampleWithReplacement(order, timeline_parameters.sample.size, timeline_parameters.sample.weights);
                  }
                  else if (timeline_parameters.sample.type == "without-replacement") {
                      order = sampleWithoutReplacement(order, timeline_parameters.sample.size);
                  }
                  else if (timeline_parameters.sample.type == "fixed-repetitions") {
                      order = repeat(order, timeline_parameters.sample.size, false);
                  }
                  else if (timeline_parameters.sample.type == "alternate-groups") {
                      order = shuffleAlternateGroups(timeline_parameters.sample.groups, timeline_parameters.sample.randomize_group_order);
                  }
                  else {
                      console.error('Invalid type in timeline sample parameters. Valid options for type are "custom", "with-replacement", "without-replacement", "fixed-repetitions", and "alternate-groups"');
                  }
              }
              if (timeline_parameters.randomize_order) {
                  order = shuffle(order);
              }
              this.progress.order = order;
          }
          // next variable set
          nextSet() {
              this.progress.current_location = -1;
              this.progress.current_variable_set++;
              for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
                  this.timeline_parameters.timeline[i].reset();
              }
          }
          // update the current trial node to be completed
          // returns true if the node is complete after advance (all subnodes are also complete)
          // returns false otherwise
          advance() {
              const progress = this.progress;
              const timeline_parameters = this.timeline_parameters;
              const internal = this.jsPsych.internal;
              // first check to see if done
              if (progress.done) {
                  return true;
              }
              // if node has not started yet (progress.current_location == -1),
              // then try to start the node.
              if (progress.current_location == -1) {
                  // check for on_timeline_start and conditonal function on nodes with timelines
                  if (typeof timeline_parameters !== "undefined") {
                      // only run the conditional function if this is the first repetition of the timeline when
                      // repetitions > 1, and only when on the first variable set
                      if (typeof timeline_parameters.conditional_function !== "undefined" &&
                          progress.current_repetition == 0 &&
                          progress.current_variable_set == 0) {
                          internal.call_immediate = true;
                          var conditional_result = timeline_parameters.conditional_function();
                          internal.call_immediate = false;
                          // if the conditional_function() returns false, then the timeline
                          // doesn't run and is marked as complete.
                          if (conditional_result == false) {
                              progress.done = true;
                              return true;
                          }
                      }
                      // if we reach this point then the node has its own timeline and will start
                      // so we need to check if there is an on_timeline_start function if we are on the first variable set
                      if (typeof timeline_parameters.on_timeline_start !== "undefined" &&
                          progress.current_variable_set == 0) {
                          timeline_parameters.on_timeline_start();
                      }
                  }
                  // if we reach this point, then either the node doesn't have a timeline of the
                  // conditional function returned true and it can start
                  progress.current_location = 0;
                  // call advance again on this node now that it is pointing to a new location
                  return this.advance();
              }
              // if this node has a timeline, propogate down to the current trial.
              if (typeof timeline_parameters !== "undefined") {
                  var have_node_to_run = false;
                  // keep incrementing the location in the timeline until one of the nodes reached is incomplete
                  while (progress.current_location < timeline_parameters.timeline.length &&
                      have_node_to_run == false) {
                      // check to see if the node currently pointed at is done
                      var target_complete = timeline_parameters.timeline[progress.current_location].advance();
                      if (!target_complete) {
                          have_node_to_run = true;
                          return false;
                      }
                      else {
                          progress.current_location++;
                      }
                  }
                  // if we've reached the end of the timeline (which, if the code is here, we have)
                  // there are a few steps to see what to do next...
                  // first, check the timeline_variables to see if we need to loop through again
                  // with a new set of variables
                  if (progress.current_variable_set < progress.order.length - 1) {
                      // reset the progress of the node to be with the new set
                      this.nextSet();
                      // then try to advance this node again.
                      return this.advance();
                  }
                  // if we're all done with the timeline_variables, then check to see if there are more repetitions
                  else if (progress.current_repetition < timeline_parameters.repetitions - 1) {
                      this.nextRepetiton();
                      // check to see if there is an on_timeline_finish function
                      if (typeof timeline_parameters.on_timeline_finish !== "undefined") {
                          timeline_parameters.on_timeline_finish();
                      }
                      return this.advance();
                  }
                  // if we're all done with the repetitions...
                  else {
                      // check to see if there is an on_timeline_finish function
                      if (typeof timeline_parameters.on_timeline_finish !== "undefined") {
                          timeline_parameters.on_timeline_finish();
                      }
                      // if we're all done with the repetitions, check if there is a loop function.
                      if (typeof timeline_parameters.loop_function !== "undefined") {
                          internal.call_immediate = true;
                          if (timeline_parameters.loop_function(this.generatedData())) {
                              this.reset();
                              internal.call_immediate = false;
                              return this.parent_node.advance();
                          }
                          else {
                              progress.done = true;
                              internal.call_immediate = false;
                              return true;
                          }
                      }
                  }
                  // no more loops on this timeline, we're done!
                  progress.done = true;
                  return true;
              }
          }
          // check the status of the done flag
          isComplete() {
              return this.progress.done;
          }
          // getter method for timeline variables
          getTimelineVariableValue(variable_name) {
              if (typeof this.timeline_parameters == "undefined") {
                  return undefined;
              }
              var v = this.timeline_parameters.timeline_variables[this.progress.order[this.progress.current_variable_set]][variable_name];
              return v;
          }
          // recursive upward search for timeline variables
          findTimelineVariable(variable_name) {
              var v = this.getTimelineVariableValue(variable_name);
              if (typeof v == "undefined") {
                  if (typeof this.parent_node !== "undefined") {
                      return this.parent_node.findTimelineVariable(variable_name);
                  }
                  else {
                      return undefined;
                  }
              }
              else {
                  return v;
              }
          }
          // recursive downward search for active trial to extract timeline variable
          timelineVariable(variable_name) {
              if (typeof this.timeline_parameters == "undefined") {
                  return this.findTimelineVariable(variable_name);
              }
              else {
                  // if progress.current_location is -1, then the timeline variable is being evaluated
                  // in a function that runs prior to the trial starting, so we should treat that trial
                  // as being the active trial for purposes of finding the value of the timeline variable
                  var loc = Math.max(0, this.progress.current_location);
                  // if loc is greater than the number of elements on this timeline, then the timeline
                  // variable is being evaluated in a function that runs after the trial on the timeline
                  // are complete but before advancing to the next (like a loop_function).
                  // treat the last active trial as the active trial for this purpose.
                  if (loc == this.timeline_parameters.timeline.length) {
                      loc = loc - 1;
                  }
                  // now find the variable
                  return this.timeline_parameters.timeline[loc].timelineVariable(variable_name);
              }
          }
          // recursively get all the timeline variables for this trial
          allTimelineVariables() {
              var all_tvs = this.allTimelineVariablesNames();
              var all_tvs_vals = {};
              for (var i = 0; i < all_tvs.length; i++) {
                  all_tvs_vals[all_tvs[i]] = this.timelineVariable(all_tvs[i]);
              }
              return all_tvs_vals;
          }
          // helper to get all the names at this stage.
          allTimelineVariablesNames(so_far = []) {
              if (typeof this.timeline_parameters !== "undefined") {
                  so_far = so_far.concat(Object.keys(this.timeline_parameters.timeline_variables[this.progress.order[this.progress.current_variable_set]]));
                  // if progress.current_location is -1, then the timeline variable is being evaluated
                  // in a function that runs prior to the trial starting, so we should treat that trial
                  // as being the active trial for purposes of finding the value of the timeline variable
                  var loc = Math.max(0, this.progress.current_location);
                  // if loc is greater than the number of elements on this timeline, then the timeline
                  // variable is being evaluated in a function that runs after the trial on the timeline
                  // are complete but before advancing to the next (like a loop_function).
                  // treat the last active trial as the active trial for this purpose.
                  if (loc == this.timeline_parameters.timeline.length) {
                      loc = loc - 1;
                  }
                  // now find the variable
                  return this.timeline_parameters.timeline[loc].allTimelineVariablesNames(so_far);
              }
              if (typeof this.timeline_parameters == "undefined") {
                  return so_far;
              }
          }
          // recursively get the number of **trials** contained in the timeline
          // assuming that while loops execute exactly once and if conditionals
          // always run
          length() {
              var length = 0;
              if (typeof this.timeline_parameters !== "undefined") {
                  for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
                      length += this.timeline_parameters.timeline[i].length();
                  }
              }
              else {
                  return 1;
              }
              return length;
          }
          // return the percentage of trials completed, grouped at the first child level
          // counts a set of trials as complete when the child node is done
          percentComplete() {
              var total_trials = this.length();
              var completed_trials = 0;
              for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
                  if (this.timeline_parameters.timeline[i].isComplete()) {
                      completed_trials += this.timeline_parameters.timeline[i].length();
                  }
              }
              return (completed_trials / total_trials) * 100;
          }
          // resets the node and all subnodes to original state
          // but increments the current_iteration counter
          reset() {
              this.progress.current_location = -1;
              this.progress.current_repetition = 0;
              this.progress.current_variable_set = 0;
              this.progress.current_iteration++;
              this.progress.done = false;
              this.setTimelineVariablesOrder();
              if (typeof this.timeline_parameters != "undefined") {
                  for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
                      this.timeline_parameters.timeline[i].reset();
                  }
              }
          }
          // mark this node as finished
          end() {
              this.progress.done = true;
          }
          // recursively end whatever sub-node is running the current trial
          endActiveNode() {
              if (typeof this.timeline_parameters == "undefined") {
                  this.end();
                  this.parent_node.end();
              }
              else {
                  this.timeline_parameters.timeline[this.progress.current_location].endActiveNode();
              }
          }
          // get a unique ID associated with this node
          // the ID reflects the current iteration through this node.
          ID() {
              var id = "";
              if (typeof this.parent_node == "undefined") {
                  return "0." + this.progress.current_iteration;
              }
              else {
                  id += this.parent_node.ID() + "-";
                  id += this.relative_id + "." + this.progress.current_iteration;
                  return id;
              }
          }
          // get the ID of the active trial
          activeID() {
              if (typeof this.timeline_parameters == "undefined") {
                  return this.ID();
              }
              else {
                  return this.timeline_parameters.timeline[this.progress.current_location].activeID();
              }
          }
          // get all the data generated within this node
          generatedData() {
              return this.jsPsych.data.getDataByTimelineNode(this.ID());
          }
          // get all the trials of a particular type
          trialsOfType(type) {
              if (typeof this.timeline_parameters == "undefined") {
                  if (this.trial_parameters.type == type) {
                      return this.trial_parameters;
                  }
                  else {
                      return [];
                  }
              }
              else {
                  var trials = [];
                  for (var i = 0; i < this.timeline_parameters.timeline.length; i++) {
                      var t = this.timeline_parameters.timeline[i].trialsOfType(type);
                      trials = trials.concat(t);
                  }
                  return trials;
              }
          }
          // add new trials to end of this timeline
          insert(parameters) {
              if (typeof this.timeline_parameters === "undefined") {
                  console.error("Cannot add new trials to a trial-level node.");
              }
              else {
                  this.timeline_parameters.timeline.push(new TimelineNode(this.jsPsych, Object.assign(Object.assign({}, this.node_trial_data), parameters), this, this.timeline_parameters.timeline.length));
              }
          }
      }
  
      function delay(ms) {
          return new Promise((resolve) => setTimeout(resolve, ms));
      }
      class JsPsych {
          constructor(options) {
              this.extensions = {};
              this.turk = turk;
              this.randomization = randomization;
              this.utils = utils;
              //
              // private variables
              //
              /**
               * options
               */
              this.opts = {};
              // flow control
              this.global_trial_index = 0;
              this.current_trial = {};
              this.current_trial_finished = false;
              /**
               * is the experiment paused?
               */
              this.paused = false;
              this.waiting = false;
              /**
               * is the page retrieved directly via file:// protocol (true) or hosted on a server (false)?
               */
              this.file_protocol = false;
              /**
               * is the experiment running in `simulate()` mode
               */
              this.simulation_mode = null;
              // storing a single webaudio context to prevent problems with multiple inits
              // of jsPsych
              this.webaudio_context = null;
              this.internal = {
                  /**
                   * this flag is used to determine whether we are in a scope where
                   * jsPsych.timelineVariable() should be executed immediately or
                   * whether it should return a function to access the variable later.
                   *
                   **/
                  call_immediate: false,
              };
              this.progress_bar_amount = 0;
              // override default options if user specifies an option
              options = Object.assign({ display_element: undefined, on_finish: () => { }, on_trial_start: () => { }, on_trial_finish: () => { }, on_data_update: () => { }, on_interaction_data_update: () => { }, on_close: () => { }, use_webaudio: true, exclusions: {}, show_progress_bar: false, message_progress_bar: "Completion Progress", auto_update_progress_bar: true, default_iti: 0, minimum_valid_rt: 0, experiment_width: null, override_safe_mode: false, case_sensitive_responses: false, extensions: [] }, options);
              this.opts = options;
              autoBind(this); // so we can pass JsPsych methods as callbacks and `this` remains the JsPsych instance
              this.webaudio_context =
                  typeof window !== "undefined" && typeof window.AudioContext !== "undefined"
                      ? new AudioContext()
                      : null;
              // detect whether page is running in browser as a local file, and if so, disable web audio and video preloading to prevent CORS issues
              if (window.location.protocol == "file:" &&
                  (options.override_safe_mode === false || typeof options.override_safe_mode === "undefined")) {
                  options.use_webaudio = false;
                  this.file_protocol = true;
                  console.warn("jsPsych detected that it is running via the file:// protocol and not on a web server. " +
                      "To prevent issues with cross-origin requests, Web Audio and video preloading have been disabled. " +
                      "If you would like to override this setting, you can set 'override_safe_mode' to 'true' in initJsPsych. " +
                      "For more information, see: https://www.jspsych.org/overview/running-experiments");
              }
              // initialize modules
              this.data = new JsPsychData(this);
              this.pluginAPI = createJointPluginAPIObject(this);
              // create instances of extensions
              for (const extension of options.extensions) {
                  this.extensions[extension.type.info.name] = new extension.type(this);
              }
              // initialize audio context based on options and browser capabilities
              this.pluginAPI.initAudio();
          }
          version() {
              return version;
          }
          /**
           * Starts an experiment using the provided timeline and returns a promise that is resolved when
           * the experiment is finished.
           *
           * @param timeline The timeline to be run
           */
          run(timeline) {
              return __awaiter(this, void 0, void 0, function* () {
                  if (typeof timeline === "undefined") {
                      console.error("No timeline declared in jsPsych.run. Cannot start experiment.");
                  }
                  if (timeline.length === 0) {
                      console.error("No trials have been added to the timeline (the timeline is an empty array). Cannot start experiment.");
                  }
                  // create experiment timeline
                  this.timelineDescription = timeline;
                  this.timeline = new TimelineNode(this, { timeline });
                  yield this.prepareDom();
                  yield this.checkExclusions(this.opts.exclusions);
                  yield this.loadExtensions(this.opts.extensions);
                  document.documentElement.setAttribute("jspsych", "present");
                  this.startExperiment();
                  yield this.finished;
              });
          }
          simulate(timeline, simulation_mode = "data-only", simulation_options = {}) {
              return __awaiter(this, void 0, void 0, function* () {
                  this.simulation_mode = simulation_mode;
                  this.simulation_options = simulation_options;
                  yield this.run(timeline);
              });
          }
          getProgress() {
              return {
                  total_trials: typeof this.timeline === "undefined" ? undefined : this.timeline.length(),
                  current_trial_global: this.global_trial_index,
                  percent_complete: typeof this.timeline === "undefined" ? 0 : this.timeline.percentComplete(),
              };
          }
          getStartTime() {
              return this.exp_start_time;
          }
          getTotalTime() {
              if (typeof this.exp_start_time === "undefined") {
                  return 0;
              }
              return new Date().getTime() - this.exp_start_time.getTime();
          }
          getDisplayElement() {
              return this.DOM_target;
          }
          getDisplayContainerElement() {
              return this.DOM_container;
          }
          finishTrial(data = {}) {
              if (this.current_trial_finished) {
                  return;
              }
              this.current_trial_finished = true;
              // remove any CSS classes that were added to the DOM via css_classes parameter
              if (typeof this.current_trial.css_classes !== "undefined" &&
                  Array.isArray(this.current_trial.css_classes)) {
                  this.DOM_target.classList.remove(...this.current_trial.css_classes);
              }
              // write the data from the trial
              this.data.write(data);
              // get back the data with all of the defaults in
              const trial_data = this.data.get().filter({ trial_index: this.global_trial_index });
              // for trial-level callbacks, we just want to pass in a reference to the values
              // of the DataCollection, for easy access and editing.
              const trial_data_values = trial_data.values()[0];
              const current_trial = this.current_trial;
              if (typeof current_trial.save_trial_parameters === "object") {
                  for (const key of Object.keys(current_trial.save_trial_parameters)) {
                      const key_val = current_trial.save_trial_parameters[key];
                      if (key_val === true) {
                          if (typeof current_trial[key] === "undefined") {
                              console.warn(`Invalid parameter specified in save_trial_parameters. Trial has no property called "${key}".`);
                          }
                          else if (typeof current_trial[key] === "function") {
                              trial_data_values[key] = current_trial[key].toString();
                          }
                          else {
                              trial_data_values[key] = current_trial[key];
                          }
                      }
                      if (key_val === false) {
                          // we don't allow internal_node_id or trial_index to be deleted because it would break other things
                          if (key !== "internal_node_id" && key !== "trial_index") {
                              delete trial_data_values[key];
                          }
                      }
                  }
              }
              // handle extension callbacks
              if (Array.isArray(current_trial.extensions)) {
                  for (const extension of current_trial.extensions) {
                      const ext_data_values = this.extensions[extension.type.info.name].on_finish(extension.params);
                      Object.assign(trial_data_values, ext_data_values);
                  }
              }
              // about to execute lots of callbacks, so switch context.
              this.internal.call_immediate = true;
              // handle callback at plugin level
              if (typeof current_trial.on_finish === "function") {
                  current_trial.on_finish(trial_data_values);
              }
              // handle callback at whole-experiment level
              this.opts.on_trial_finish(trial_data_values);
              // after the above callbacks are complete, then the data should be finalized
              // for this trial. call the on_data_update handler, passing in the same
              // data object that just went through the trial's finish handlers.
              this.opts.on_data_update(trial_data_values);
              // done with callbacks
              this.internal.call_immediate = false;
              // wait for iti
              if (this.simulation_mode === "data-only") {
                  this.nextTrial();
              }
              else if (typeof current_trial.post_trial_gap === null ||
                  typeof current_trial.post_trial_gap === "undefined") {
                  if (this.opts.default_iti > 0) {
                      setTimeout(this.nextTrial, this.opts.default_iti);
                  }
                  else {
                      this.nextTrial();
                  }
              }
              else {
                  if (current_trial.post_trial_gap > 0) {
                      setTimeout(this.nextTrial, current_trial.post_trial_gap);
                  }
                  else {
                      this.nextTrial();
                  }
              }
          }
          endExperiment(end_message = "", data = {}) {
              this.timeline.end_message = end_message;
              this.timeline.end();
              this.pluginAPI.cancelAllKeyboardResponses();
              this.pluginAPI.clearAllTimeouts();
              this.finishTrial(data);
          }
          endCurrentTimeline() {
              this.timeline.endActiveNode();
          }
          getCurrentTrial() {
              return this.current_trial;
          }
          getInitSettings() {
              return this.opts;
          }
          getCurrentTimelineNodeID() {
              return this.timeline.activeID();
          }
          timelineVariable(varname, immediate = false) {
              if (this.internal.call_immediate || immediate === true) {
                  return this.timeline.timelineVariable(varname);
              }
              else {
                  return {
                      timelineVariablePlaceholder: true,
                      timelineVariableFunction: () => this.timeline.timelineVariable(varname),
                  };
              }
          }
          getAllTimelineVariables() {
              return this.timeline.allTimelineVariables();
          }
          addNodeToEndOfTimeline(new_timeline, preload_callback) {
              this.timeline.insert(new_timeline);
          }
          pauseExperiment() {
              this.paused = true;
          }
          resumeExperiment() {
              this.paused = false;
              if (this.waiting) {
                  this.waiting = false;
                  this.nextTrial();
              }
          }
          loadFail(message) {
              message = message || "<p>The experiment failed to load.</p>";
              this.DOM_target.innerHTML = message;
          }
          getSafeModeStatus() {
              return this.file_protocol;
          }
          getTimeline() {
              return this.timelineDescription;
          }
          prepareDom() {
              return __awaiter(this, void 0, void 0, function* () {
                  // Wait until the document is ready
                  if (document.readyState !== "complete") {
                      yield new Promise((resolve) => {
                          window.addEventListener("load", resolve);
                      });
                  }
                  const options = this.opts;
                  // set DOM element where jsPsych will render content
                  // if undefined, then jsPsych will use the <body> tag and the entire page
                  if (typeof options.display_element === "undefined") {
                      // check if there is a body element on the page
                      const body = document.querySelector("body");
                      if (body === null) {
                          document.documentElement.appendChild(document.createElement("body"));
                      }
                      // using the full page, so we need the HTML element to
                      // have 100% height, and body to be full width and height with
                      // no margin
                      document.querySelector("html").style.height = "100%";
                      document.querySelector("body").style.margin = "0px";
                      document.querySelector("body").style.height = "100%";
                      document.querySelector("body").style.width = "100%";
                      options.display_element = document.querySelector("body");
                  }
                  else {
                      // make sure that the display element exists on the page
                      const display = options.display_element instanceof Element
                          ? options.display_element
                          : document.querySelector("#" + options.display_element);
                      if (display === null) {
                          console.error("The display_element specified in initJsPsych() does not exist in the DOM.");
                      }
                      else {
                          options.display_element = display;
                      }
                  }
                  options.display_element.innerHTML =
                      '<div class="jspsych-content-wrapper"><div id="jspsych-content"></div></div>';
                  this.DOM_container = options.display_element;
                  this.DOM_target = document.querySelector("#jspsych-content");
                  // set experiment_width if not null
                  if (options.experiment_width !== null) {
                      this.DOM_target.style.width = options.experiment_width + "px";
                  }
                  // add tabIndex attribute to scope event listeners
                  options.display_element.tabIndex = 0;
                  // add CSS class to DOM_target
                  if (options.display_element.className.indexOf("jspsych-display-element") === -1) {
                      options.display_element.className += " jspsych-display-element";
                  }
                  this.DOM_target.className += "jspsych-content";
                  // create listeners for user browser interaction
                  this.data.createInteractionListeners();
                  // add event for closing window
                  window.addEventListener("beforeunload", options.on_close);
              });
          }
          loadExtensions(extensions) {
              return __awaiter(this, void 0, void 0, function* () {
                  // run the .initialize method of any extensions that are in use
                  // these should return a Promise to indicate when loading is complete
                  try {
                      yield Promise.all(extensions.map((extension) => this.extensions[extension.type.info.name].initialize(extension.params || {})));
                  }
                  catch (error_message) {
                      console.error(error_message);
                      throw new Error(error_message);
                  }
              });
          }
          startExperiment() {
              this.finished = new Promise((resolve) => {
                  this.resolveFinishedPromise = resolve;
              });
              // show progress bar if requested
              if (this.opts.show_progress_bar === true) {
                  this.drawProgressBar(this.opts.message_progress_bar);
              }
              // record the start time
              this.exp_start_time = new Date();
              // begin!
              this.timeline.advance();
              this.doTrial(this.timeline.trial());
          }
          finishExperiment() {
              const finish_result = this.opts.on_finish(this.data.get());
              const done_handler = () => {
                  if (typeof this.timeline.end_message !== "undefined") {
                      this.DOM_target.innerHTML = this.timeline.end_message;
                  }
                  this.resolveFinishedPromise();
              };
              if (finish_result) {
                  Promise.resolve(finish_result).then(done_handler);
              }
              else {
                  done_handler();
              }
          }
          nextTrial() {
              // if experiment is paused, don't do anything.
              if (this.paused) {
                  this.waiting = true;
                  return;
              }
              this.global_trial_index++;
              // advance timeline
              this.timeline.markCurrentTrialComplete();
              const complete = this.timeline.advance();
              // update progress bar if shown
              if (this.opts.show_progress_bar === true && this.opts.auto_update_progress_bar === true) {
                  this.updateProgressBar();
              }
              // check if experiment is over
              if (complete) {
                  this.finishExperiment();
                  return;
              }
              this.doTrial(this.timeline.trial());
          }
          doTrial(trial) {
              this.current_trial = trial;
              this.current_trial_finished = false;
              // process all timeline variables for this trial
              this.evaluateTimelineVariables(trial);
              if (typeof trial.type === "string") {
                  throw new MigrationError("A string was provided as the trial's `type` parameter. Since jsPsych v7, the `type` parameter needs to be a plugin object.");
              }
              // instantiate the plugin for this trial
              trial.type = Object.assign(Object.assign({}, autoBind(new trial.type(this))), { info: trial.type.info });
              // evaluate variables that are functions
              this.evaluateFunctionParameters(trial);
              // get default values for parameters
              this.setDefaultValues(trial);
              // about to execute callbacks
              this.internal.call_immediate = true;
              // call experiment wide callback
              this.opts.on_trial_start(trial);
              // call trial specific callback if it exists
              if (typeof trial.on_start === "function") {
                  trial.on_start(trial);
              }
              // call any on_start functions for extensions
              if (Array.isArray(trial.extensions)) {
                  for (const extension of trial.extensions) {
                      this.extensions[extension.type.info.name].on_start(extension.params);
                  }
              }
              // apply the focus to the element containing the experiment.
              this.DOM_container.focus();
              // reset the scroll on the DOM target
              this.DOM_target.scrollTop = 0;
              // add CSS classes to the DOM_target if they exist in trial.css_classes
              if (typeof trial.css_classes !== "undefined") {
                  if (!Array.isArray(trial.css_classes) && typeof trial.css_classes === "string") {
                      trial.css_classes = [trial.css_classes];
                  }
                  if (Array.isArray(trial.css_classes)) {
                      this.DOM_target.classList.add(...trial.css_classes);
                  }
              }
              // setup on_load event callback
              const load_callback = () => {
                  if (typeof trial.on_load === "function") {
                      trial.on_load();
                  }
                  // call any on_load functions for extensions
                  if (Array.isArray(trial.extensions)) {
                      for (const extension of trial.extensions) {
                          this.extensions[extension.type.info.name].on_load(extension.params);
                      }
                  }
              };
              let trial_complete;
              if (!this.simulation_mode) {
                  trial_complete = trial.type.trial(this.DOM_target, trial, load_callback);
              }
              if (this.simulation_mode) {
                  // check if the trial supports simulation
                  if (trial.type.simulate) {
                      let trial_sim_opts;
                      if (!trial.simulation_options) {
                          trial_sim_opts = this.simulation_options.default;
                      }
                      if (trial.simulation_options) {
                          if (typeof trial.simulation_options == "string") {
                              if (this.simulation_options[trial.simulation_options]) {
                                  trial_sim_opts = this.simulation_options[trial.simulation_options];
                              }
                              else if (this.simulation_options.default) {
                                  console.log(`No matching simulation options found for "${trial.simulation_options}". Using "default" options.`);
                                  trial_sim_opts = this.simulation_options.default;
                              }
                              else {
                                  console.log(`No matching simulation options found for "${trial.simulation_options}" and no "default" options provided. Using the default values provided by the plugin.`);
                                  trial_sim_opts = {};
                              }
                          }
                          else {
                              trial_sim_opts = trial.simulation_options;
                          }
                      }
                      trial_sim_opts = this.utils.deepCopy(trial_sim_opts);
                      trial_sim_opts = this.replaceFunctionsWithValues(trial_sim_opts, null);
                      if ((trial_sim_opts === null || trial_sim_opts === void 0 ? void 0 : trial_sim_opts.simulate) === false) {
                          trial_complete = trial.type.trial(this.DOM_target, trial, load_callback);
                      }
                      else {
                          trial_complete = trial.type.simulate(trial, (trial_sim_opts === null || trial_sim_opts === void 0 ? void 0 : trial_sim_opts.mode) || this.simulation_mode, trial_sim_opts, load_callback);
                      }
                  }
                  else {
                      // trial doesn't have a simulate method, so just run as usual
                      trial_complete = trial.type.trial(this.DOM_target, trial, load_callback);
                  }
              }
              // see if trial_complete is a Promise by looking for .then() function
              const is_promise = trial_complete && typeof trial_complete.then == "function";
              // in simulation mode we let the simulate function call the load_callback always.
              if (!is_promise && !this.simulation_mode) {
                  load_callback();
              }
              // done with callbacks
              this.internal.call_immediate = false;
          }
          evaluateTimelineVariables(trial) {
              for (const key of Object.keys(trial)) {
                  // timeline variables on the root level
                  if (typeof trial[key] === "object" &&
                      trial[key] !== null &&
                      typeof trial[key].timelineVariablePlaceholder !== "undefined") {
                      /*trial[key].toString().replace(/\s/g, "") ==
                        "function(){returntimeline.timelineVariable(varname);}"
                    )*/ trial[key] = trial[key].timelineVariableFunction();
                  }
                  // timeline variables that are nested in objects
                  if (typeof trial[key] === "object" && trial[key] !== null) {
                      this.evaluateTimelineVariables(trial[key]);
                  }
              }
          }
          evaluateFunctionParameters(trial) {
              // set a flag so that jsPsych.timelineVariable() is immediately executed in this context
              this.internal.call_immediate = true;
              // iterate over each parameter
              for (const key of Object.keys(trial)) {
                  // check to make sure parameter is not "type", since that was eval'd above.
                  if (key !== "type") {
                      // this if statement is checking to see if the parameter type is expected to be a function, in which case we should NOT evaluate it.
                      // the first line checks if the parameter is defined in the universalPluginParameters set
                      // the second line checks the plugin-specific parameters
                      if (typeof universalPluginParameters[key] !== "undefined" &&
                          universalPluginParameters[key].type !== exports.ParameterType.FUNCTION) {
                          trial[key] = this.replaceFunctionsWithValues(trial[key], null);
                      }
                      if (typeof trial.type.info.parameters[key] !== "undefined" &&
                          trial.type.info.parameters[key].type !== exports.ParameterType.FUNCTION) {
                          trial[key] = this.replaceFunctionsWithValues(trial[key], trial.type.info.parameters[key]);
                      }
                  }
              }
              // reset so jsPsych.timelineVariable() is no longer immediately executed
              this.internal.call_immediate = false;
          }
          replaceFunctionsWithValues(obj, info) {
              // null typeof is 'object' (?!?!), so need to run this first!
              if (obj === null) {
                  return obj;
              }
              // arrays
              else if (Array.isArray(obj)) {
                  for (let i = 0; i < obj.length; i++) {
                      obj[i] = this.replaceFunctionsWithValues(obj[i], info);
                  }
              }
              // objects
              else if (typeof obj === "object") {
                  if (info === null || !info.nested) {
                      for (const key of Object.keys(obj)) {
                          if (key === "type") {
                              // Ignore the object's `type` field because it contains a plugin and we do not want to
                              // call plugin functions
                              continue;
                          }
                          obj[key] = this.replaceFunctionsWithValues(obj[key], null);
                      }
                  }
                  else {
                      for (const key of Object.keys(obj)) {
                          if (typeof info.nested[key] === "object" &&
                              info.nested[key].type !== exports.ParameterType.FUNCTION) {
                              obj[key] = this.replaceFunctionsWithValues(obj[key], info.nested[key]);
                          }
                      }
                  }
              }
              else if (typeof obj === "function") {
                  return obj();
              }
              return obj;
          }
          setDefaultValues(trial) {
              for (const param in trial.type.info.parameters) {
                  // check if parameter is complex with nested defaults
                  if (trial.type.info.parameters[param].type === exports.ParameterType.COMPLEX) {
                      if (trial.type.info.parameters[param].array === true) {
                          // iterate over each entry in the array
                          trial[param].forEach(function (ip, i) {
                              // check each parameter in the plugin description
                              for (const p in trial.type.info.parameters[param].nested) {
                                  if (typeof trial[param][i][p] === "undefined" || trial[param][i][p] === null) {
                                      if (typeof trial.type.info.parameters[param].nested[p].default === "undefined") {
                                          console.error("You must specify a value for the " +
                                              p +
                                              " parameter (nested in the " +
                                              param +
                                              " parameter) in the " +
                                              trial.type +
                                              " plugin.");
                                      }
                                      else {
                                          trial[param][i][p] = trial.type.info.parameters[param].nested[p].default;
                                      }
                                  }
                              }
                          });
                      }
                  }
                  // if it's not nested, checking is much easier and do that here:
                  else if (typeof trial[param] === "undefined" || trial[param] === null) {
                      if (typeof trial.type.info.parameters[param].default === "undefined") {
                          console.error("You must specify a value for the " +
                              param +
                              " parameter in the " +
                              trial.type.info.name +
                              " plugin.");
                      }
                      else {
                          trial[param] = trial.type.info.parameters[param].default;
                      }
                  }
              }
          }
          checkExclusions(exclusions) {
              return __awaiter(this, void 0, void 0, function* () {
                  if (exclusions.min_width || exclusions.min_height || exclusions.audio) {
                      console.warn("The exclusions option in `initJsPsych()` is deprecated and will be removed in a future version. We recommend using the browser-check plugin instead. See https://www.jspsych.org/latest/plugins/browser-check/.");
                  }
                  // MINIMUM SIZE
                  if (exclusions.min_width || exclusions.min_height) {
                      const mw = exclusions.min_width || 0;
                      const mh = exclusions.min_height || 0;
                      if (window.innerWidth < mw || window.innerHeight < mh) {
                          this.getDisplayElement().innerHTML =
                              "<p>Your browser window is too small to complete this experiment. " +
                                  "Please maximize the size of your browser window. If your browser window is already maximized, " +
                                  "you will not be able to complete this experiment.</p>" +
                                  "<p>The minimum width is " +
                                  mw +
                                  "px. Your current width is " +
                                  window.innerWidth +
                                  "px.</p>" +
                                  "<p>The minimum height is " +
                                  mh +
                                  "px. Your current height is " +
                                  window.innerHeight +
                                  "px.</p>";
                          // Wait for window size to increase
                          while (window.innerWidth < mw || window.innerHeight < mh) {
                              yield delay(100);
                          }
                          this.getDisplayElement().innerHTML = "";
                      }
                  }
                  // WEB AUDIO API
                  if (typeof exclusions.audio !== "undefined" && exclusions.audio) {
                      if (!window.hasOwnProperty("AudioContext") && !window.hasOwnProperty("webkitAudioContext")) {
                          this.getDisplayElement().innerHTML =
                              "<p>Your browser does not support the WebAudio API, which means that you will not " +
                                  "be able to complete the experiment.</p><p>Browsers that support the WebAudio API include " +
                                  "Chrome, Firefox, Safari, and Edge.</p>";
                          throw new Error();
                      }
                  }
              });
          }
          drawProgressBar(msg) {
              document
                  .querySelector(".jspsych-display-element")
                  .insertAdjacentHTML("afterbegin", '<div id="jspsych-progressbar-container">' +
                  "<span>" +
                  msg +
                  "</span>" +
                  '<div id="jspsych-progressbar-outer">' +
                  '<div id="jspsych-progressbar-inner"></div>' +
                  "</div></div>");
          }
          updateProgressBar() {
              this.setProgressBar(this.getProgress().percent_complete / 100);
          }
          setProgressBar(proportion_complete) {
              proportion_complete = Math.max(Math.min(1, proportion_complete), 0);
              document.querySelector("#jspsych-progressbar-inner").style.width =
                  proportion_complete * 100 + "%";
              this.progress_bar_amount = proportion_complete;
          }
          getProgressBarCompleted() {
              return this.progress_bar_amount;
          }
      }
  
      // temporary patch for Safari
      if (typeof window !== "undefined" &&
          window.hasOwnProperty("webkitAudioContext") &&
          !window.hasOwnProperty("AudioContext")) {
          // @ts-expect-error
          window.AudioContext = webkitAudioContext;
      }
      // end patch
      // The following function provides a uniform interface to initialize jsPsych, no matter whether a
      // browser supports ES6 classes or not (and whether the ES6 build or the Babel build is used).
      /**
       * Creates a new JsPsych instance using the provided options.
       *
       * @param options The options to pass to the JsPsych constructor
       * @returns A new JsPsych instance
       */
      function initJsPsych(options) {
          const jsPsych = new JsPsych(options);
          // Handle invocations of non-existent v6 methods with migration errors
          const migrationMessages = {
              init: "`jsPsych.init()` was replaced by `initJsPsych()` in jsPsych v7.",
              ALL_KEYS: 'jsPsych.ALL_KEYS was replaced by the "ALL_KEYS" string in jsPsych v7.',
              NO_KEYS: 'jsPsych.NO_KEYS was replaced by the "NO_KEYS" string in jsPsych v7.',
              // Getter functions that were renamed
              currentTimelineNodeID: "`currentTimelineNodeID()` was renamed to `getCurrentTimelineNodeID()` in jsPsych v7.",
              progress: "`progress()` was renamed to `getProgress()` in jsPsych v7.",
              startTime: "`startTime()` was renamed to `getStartTime()` in jsPsych v7.",
              totalTime: "`totalTime()` was renamed to `getTotalTime()` in jsPsych v7.",
              currentTrial: "`currentTrial()` was renamed to `getCurrentTrial()` in jsPsych v7.",
              initSettings: "`initSettings()` was renamed to `getInitSettings()` in jsPsych v7.",
              allTimelineVariables: "`allTimelineVariables()` was renamed to `getAllTimelineVariables()` in jsPsych v7.",
          };
          Object.defineProperties(jsPsych, Object.fromEntries(Object.entries(migrationMessages).map(([key, message]) => [
              key,
              {
                  get() {
                      throw new MigrationError(message);
                  },
              },
          ])));
          return jsPsych;
      }
  
      exports.JsPsych = JsPsych;
      exports.initJsPsych = initJsPsych;
      exports.universalPluginParameters = universalPluginParameters;
  
      Object.defineProperty(exports, '__esModule', { value: true });
  
      return exports;
  
  })({});
  var initJsPsych = jsPsychModule.initJsPsych;
  