@doenet/assignment-viewer 0.1.0-alpha-10

package/dist/index.js

@@ -0,0 +1,4222 @@
+import React, { useState, useRef, useMemo, useEffect, useReducer, useCallback, Component } from "react";
+import { DoenetViewer } from "@doenet/doenetml-iframe";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      var isInstance = false;
+      try {
+        isInstance = this instanceof a2;
+      } catch {
+      }
+      if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+var jsxRuntime = { exports: {} };
+var reactJsxRuntime_production = {};
+var hasRequiredReactJsxRuntime_production;
+function requireReactJsxRuntime_production() {
+  if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+  hasRequiredReactJsxRuntime_production = 1;
+  var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config)
+        "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type,
+      key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
+    };
+  }
+  reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactJsxRuntime_production.jsx = jsxProd;
+  reactJsxRuntime_production.jsxs = jsxProd;
+  return reactJsxRuntime_production;
+}
+var reactJsxRuntime_development = {};
+var hasRequiredReactJsxRuntime_development;
+function requireReactJsxRuntime_development() {
+  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+  hasRequiredReactJsxRuntime_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type)
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type)
+        switch ("number" === typeof type.tag && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {
+            }
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(
+          JSCompiler_inline_result,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          JSCompiler_inline_result$jscomp$0
+        );
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return false;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          displayName
+        ));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      ));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (void 0 !== children)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return "key" !== k;
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+          'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+          isStaticChildren,
+          children,
+          keys,
+          children
+        ), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(
+        maybeKey,
+        "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+      );
+      return ReactElement(
+        type,
+        children,
+        maybeKey,
+        getOwner(),
+        debugStack,
+        debugTask
+      );
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var React$1 = React, REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React$1.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    React$1 = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React$1.react_stack_bottom_frame.bind(
+      React$1,
+      UnknownOwner
+    )();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+    reactJsxRuntime_development.jsx = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        false,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+    reactJsxRuntime_development.jsxs = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        true,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+  }();
+  return reactJsxRuntime_development;
+}
+var hasRequiredJsxRuntime;
+function requireJsxRuntime() {
+  if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+  hasRequiredJsxRuntime = 1;
+  if (process.env.NODE_ENV === "production") {
+    jsxRuntime.exports = requireReactJsxRuntime_production();
+  } else {
+    jsxRuntime.exports = requireReactJsxRuntime_development();
+  }
+  return jsxRuntime.exports;
+}
+var jsxRuntimeExports = requireJsxRuntime();
+var alea$1 = { exports: {} };
+var alea = alea$1.exports;
+var hasRequiredAlea;
+function requireAlea() {
+  if (hasRequiredAlea) return alea$1.exports;
+  hasRequiredAlea = 1;
+  (function(module) {
+    (function(global, module2, define) {
+      function Alea(seed) {
+        var me = this, mash = Mash();
+        me.next = function() {
+          var t = 2091639 * me.s0 + me.c * 23283064365386963e-26;
+          me.s0 = me.s1;
+          me.s1 = me.s2;
+          return me.s2 = t - (me.c = t | 0);
+        };
+        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() * 4294967296 | 0;
+        };
+        prng.double = function() {
+          return prng() + (prng() * 2097152 | 0) * 11102230246251565e-32;
+        };
+        prng.quick = prng;
+        if (state) {
+          if (typeof state == "object") copy(state, xg);
+          prng.state = function() {
+            return copy(xg, {});
+          };
+        }
+        return prng;
+      }
+      function Mash() {
+        var n = 4022871197;
+        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 * 4294967296;
+          }
+          return (n >>> 0) * 23283064365386963e-26;
+        };
+        return mash;
+      }
+      if (module2 && module2.exports) {
+        module2.exports = impl;
+      } else {
+        this.alea = impl;
+      }
+    })(
+      alea,
+      module
+    );
+  })(alea$1);
+  return alea$1.exports;
+}
+var xor128$1 = { exports: {} };
+var xor128 = xor128$1.exports;
+var hasRequiredXor128;
+function requireXor128() {
+  if (hasRequiredXor128) return xor128$1.exports;
+  hasRequiredXor128 = 1;
+  (function(module) {
+    (function(global, module2, define) {
+      function XorGen(seed) {
+        var me = this, strseed = "";
+        me.x = 0;
+        me.y = 0;
+        me.z = 0;
+        me.w = 0;
+        me.next = function() {
+          var t = me.x ^ me.x << 11;
+          me.x = me.y;
+          me.y = me.z;
+          me.z = me.w;
+          return me.w ^= me.w >>> 19 ^ t ^ t >>> 8;
+        };
+        if (seed === (seed | 0)) {
+          me.x = seed;
+        } else {
+          strseed += seed;
+        }
+        for (var k = 0; k < strseed.length + 64; k++) {
+          me.x ^= strseed.charCodeAt(k) | 0;
+          me.next();
+        }
+      }
+      function copy(f, t) {
+        t.x = f.x;
+        t.y = f.y;
+        t.z = f.z;
+        t.w = f.w;
+        return t;
+      }
+      function impl(seed, opts) {
+        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
+          return (xg.next() >>> 0) / 4294967296;
+        };
+        prng.double = function() {
+          do {
+            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
+          } while (result === 0);
+          return result;
+        };
+        prng.int32 = xg.next;
+        prng.quick = prng;
+        if (state) {
+          if (typeof state == "object") copy(state, xg);
+          prng.state = function() {
+            return copy(xg, {});
+          };
+        }
+        return prng;
+      }
+      if (module2 && module2.exports) {
+        module2.exports = impl;
+      } else {
+        this.xor128 = impl;
+      }
+    })(
+      xor128,
+      module
+    );
+  })(xor128$1);
+  return xor128$1.exports;
+}
+var xorwow$1 = { exports: {} };
+var xorwow = xorwow$1.exports;
+var hasRequiredXorwow;
+function requireXorwow() {
+  if (hasRequiredXorwow) return xorwow$1.exports;
+  hasRequiredXorwow = 1;
+  (function(module) {
+    (function(global, module2, define) {
+      function XorGen(seed) {
+        var me = this, strseed = "";
+        me.next = function() {
+          var t = me.x ^ me.x >>> 2;
+          me.x = me.y;
+          me.y = me.z;
+          me.z = me.w;
+          me.w = me.v;
+          return (me.d = me.d + 362437 | 0) + (me.v = me.v ^ me.v << 4 ^ (t ^ t << 1)) | 0;
+        };
+        me.x = 0;
+        me.y = 0;
+        me.z = 0;
+        me.w = 0;
+        me.v = 0;
+        if (seed === (seed | 0)) {
+          me.x = seed;
+        } else {
+          strseed += seed;
+        }
+        for (var k = 0; k < strseed.length + 64; k++) {
+          me.x ^= strseed.charCodeAt(k) | 0;
+          if (k == strseed.length) {
+            me.d = me.x << 10 ^ me.x >>> 4;
+          }
+          me.next();
+        }
+      }
+      function copy(f, t) {
+        t.x = f.x;
+        t.y = f.y;
+        t.z = f.z;
+        t.w = f.w;
+        t.v = f.v;
+        t.d = f.d;
+        return t;
+      }
+      function impl(seed, opts) {
+        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
+          return (xg.next() >>> 0) / 4294967296;
+        };
+        prng.double = function() {
+          do {
+            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
+          } while (result === 0);
+          return result;
+        };
+        prng.int32 = xg.next;
+        prng.quick = prng;
+        if (state) {
+          if (typeof state == "object") copy(state, xg);
+          prng.state = function() {
+            return copy(xg, {});
+          };
+        }
+        return prng;
+      }
+      if (module2 && module2.exports) {
+        module2.exports = impl;
+      } else {
+        this.xorwow = impl;
+      }
+    })(
+      xorwow,
+      module
+    );
+  })(xorwow$1);
+  return xorwow$1.exports;
+}
+var xorshift7$1 = { exports: {} };
+var xorshift7 = xorshift7$1.exports;
+var hasRequiredXorshift7;
+function requireXorshift7() {
+  if (hasRequiredXorshift7) return xorshift7$1.exports;
+  hasRequiredXorshift7 = 1;
+  (function(module) {
+    (function(global, module2, define) {
+      function XorGen(seed) {
+        var me = this;
+        me.next = function() {
+          var X = me.x, i = me.i, t, v;
+          t = X[i];
+          t ^= t >>> 7;
+          v = t ^ t << 24;
+          t = X[i + 1 & 7];
+          v ^= t ^ t >>> 10;
+          t = X[i + 3 & 7];
+          v ^= t ^ t >>> 3;
+          t = X[i + 4 & 7];
+          v ^= t ^ t << 7;
+          t = X[i + 7 & 7];
+          t = t ^ t << 13;
+          v ^= t ^ t << 9;
+          X[i] = v;
+          me.i = i + 1 & 7;
+          return v;
+        };
+        function init(me2, seed2) {
+          var j, X = [];
+          if (seed2 === (seed2 | 0)) {
+            X[0] = seed2;
+          } else {
+            seed2 = "" + seed2;
+            for (j = 0; j < seed2.length; ++j) {
+              X[j & 7] = X[j & 7] << 15 ^ seed2.charCodeAt(j) + X[j + 1 & 7] << 13;
+            }
+          }
+          while (X.length < 8) X.push(0);
+          for (j = 0; j < 8 && X[j] === 0; ++j) ;
+          if (j == 8) X[7] = -1;
+          else X[j];
+          me2.x = X;
+          me2.i = 0;
+          for (j = 256; j > 0; --j) {
+            me2.next();
+          }
+        }
+        init(me, seed);
+      }
+      function copy(f, t) {
+        t.x = f.x.slice();
+        t.i = f.i;
+        return t;
+      }
+      function impl(seed, opts) {
+        if (seed == null) seed = +/* @__PURE__ */ new Date();
+        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
+          return (xg.next() >>> 0) / 4294967296;
+        };
+        prng.double = function() {
+          do {
+            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
+          } while (result === 0);
+          return result;
+        };
+        prng.int32 = xg.next;
+        prng.quick = prng;
+        if (state) {
+          if (state.x) copy(state, xg);
+          prng.state = function() {
+            return copy(xg, {});
+          };
+        }
+        return prng;
+      }
+      if (module2 && module2.exports) {
+        module2.exports = impl;
+      } else {
+        this.xorshift7 = impl;
+      }
+    })(
+      xorshift7,
+      module
+    );
+  })(xorshift7$1);
+  return xorshift7$1.exports;
+}
+var xor4096$1 = { exports: {} };
+var xor4096 = xor4096$1.exports;
+var hasRequiredXor4096;
+function requireXor4096() {
+  if (hasRequiredXor4096) return xor4096$1.exports;
+  hasRequiredXor4096 = 1;
+  (function(module) {
+    (function(global, module2, define) {
+      function XorGen(seed) {
+        var me = this;
+        me.next = function() {
+          var w = me.w, X = me.X, i = me.i, t, v;
+          me.w = w = w + 1640531527 | 0;
+          v = X[i + 34 & 127];
+          t = X[i = i + 1 & 127];
+          v ^= v << 13;
+          t ^= t << 17;
+          v ^= v >>> 15;
+          t ^= t >>> 12;
+          v = X[i] = v ^ t;
+          me.i = i;
+          return v + (w ^ w >>> 16) | 0;
+        };
+        function init(me2, seed2) {
+          var t, v, i, j, w, X = [], limit = 128;
+          if (seed2 === (seed2 | 0)) {
+            v = seed2;
+            seed2 = null;
+          } else {
+            seed2 = seed2 + "\0";
+            v = 0;
+            limit = Math.max(limit, seed2.length);
+          }
+          for (i = 0, j = -32; j < limit; ++j) {
+            if (seed2) v ^= seed2.charCodeAt((j + 32) % seed2.length);
+            if (j === 0) w = v;
+            v ^= v << 10;
+            v ^= v >>> 15;
+            v ^= v << 4;
+            v ^= v >>> 13;
+            if (j >= 0) {
+              w = w + 1640531527 | 0;
+              t = X[j & 127] ^= v + w;
+              i = 0 == t ? i + 1 : 0;
+            }
+          }
+          if (i >= 128) {
+            X[(seed2 && seed2.length || 0) & 127] = -1;
+          }
+          i = 127;
+          for (j = 4 * 128; j > 0; --j) {
+            v = X[i + 34 & 127];
+            t = X[i = i + 1 & 127];
+            v ^= v << 13;
+            t ^= t << 17;
+            v ^= v >>> 15;
+            t ^= t >>> 12;
+            X[i] = v ^ t;
+          }
+          me2.w = w;
+          me2.X = X;
+          me2.i = i;
+        }
+        init(me, seed);
+      }
+      function copy(f, t) {
+        t.i = f.i;
+        t.w = f.w;
+        t.X = f.X.slice();
+        return t;
+      }
+      function impl(seed, opts) {
+        if (seed == null) seed = +/* @__PURE__ */ new Date();
+        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
+          return (xg.next() >>> 0) / 4294967296;
+        };
+        prng.double = function() {
+          do {
+            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
+          } while (result === 0);
+          return result;
+        };
+        prng.int32 = xg.next;
+        prng.quick = prng;
+        if (state) {
+          if (state.X) copy(state, xg);
+          prng.state = function() {
+            return copy(xg, {});
+          };
+        }
+        return prng;
+      }
+      if (module2 && module2.exports) {
+        module2.exports = impl;
+      } else {
+        this.xor4096 = impl;
+      }
+    })(
+      xor4096,
+      // window object or global
+      module
+    );
+  })(xor4096$1);
+  return xor4096$1.exports;
+}
+var tychei$1 = { exports: {} };
+var tychei = tychei$1.exports;
+var hasRequiredTychei;
+function requireTychei() {
+  if (hasRequiredTychei) return tychei$1.exports;
+  hasRequiredTychei = 1;
+  (function(module) {
+    (function(global, module2, define) {
+      function XorGen(seed) {
+        var me = this, strseed = "";
+        me.next = function() {
+          var b = me.b, c = me.c, d = me.d, a = me.a;
+          b = b << 25 ^ b >>> 7 ^ c;
+          c = c - d | 0;
+          d = d << 24 ^ d >>> 8 ^ a;
+          a = a - b | 0;
+          me.b = b = b << 20 ^ b >>> 12 ^ c;
+          me.c = c = c - d | 0;
+          me.d = d << 16 ^ c >>> 16 ^ a;
+          return me.a = a - b | 0;
+        };
+        me.a = 0;
+        me.b = 0;
+        me.c = 2654435769 | 0;
+        me.d = 1367130551;
+        if (seed === Math.floor(seed)) {
+          me.a = seed / 4294967296 | 0;
+          me.b = seed | 0;
+        } else {
+          strseed += seed;
+        }
+        for (var k = 0; k < strseed.length + 20; k++) {
+          me.b ^= strseed.charCodeAt(k) | 0;
+          me.next();
+        }
+      }
+      function copy(f, t) {
+        t.a = f.a;
+        t.b = f.b;
+        t.c = f.c;
+        t.d = f.d;
+        return t;
+      }
+      function impl(seed, opts) {
+        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
+          return (xg.next() >>> 0) / 4294967296;
+        };
+        prng.double = function() {
+          do {
+            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
+          } while (result === 0);
+          return result;
+        };
+        prng.int32 = xg.next;
+        prng.quick = prng;
+        if (state) {
+          if (typeof state == "object") copy(state, xg);
+          prng.state = function() {
+            return copy(xg, {});
+          };
+        }
+        return prng;
+      }
+      if (module2 && module2.exports) {
+        module2.exports = impl;
+      } else {
+        this.tychei = impl;
+      }
+    })(
+      tychei,
+      module
+    );
+  })(tychei$1);
+  return tychei$1.exports;
+}
+var seedrandom$3 = { exports: {} };
+const __viteBrowserExternal = {};
+const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+var seedrandom$2 = seedrandom$3.exports;
+var hasRequiredSeedrandom$1;
+function requireSeedrandom$1() {
+  if (hasRequiredSeedrandom$1) return seedrandom$3.exports;
+  hasRequiredSeedrandom$1 = 1;
+  (function(module) {
+    (function(global, pool, math) {
+      var width = 256, chunks = 6, digits = 52, rngname = "random", startdenom = math.pow(width, chunks), significance = math.pow(2, digits), overflow = significance * 2, mask = width - 1, nodecrypto;
+      function seedrandom2(seed, options, callback) {
+        var key = [];
+        options = options == true ? { entropy: true } : options || {};
+        var shortseed = mixkey(flatten(
+          options.entropy ? [seed, tostring(pool)] : seed == null ? autoseed() : seed,
+          3
+        ), key);
+        var arc4 = new ARC4(key);
+        var prng = function() {
+          var n = arc4.g(chunks), d = startdenom, x = 0;
+          while (n < significance) {
+            n = (n + x) * width;
+            d *= width;
+            x = arc4.g(1);
+          }
+          while (n >= overflow) {
+            n /= 2;
+            d /= 2;
+            x >>>= 1;
+          }
+          return (n + x) / d;
+        };
+        prng.int32 = function() {
+          return arc4.g(4) | 0;
+        };
+        prng.quick = function() {
+          return arc4.g(4) / 4294967296;
+        };
+        prng.double = prng;
+        mixkey(tostring(arc4.S), pool);
+        return (options.pass || callback || function(prng2, seed2, is_math_call, state) {
+          if (state) {
+            if (state.S) {
+              copy(state, arc4);
+            }
+            prng2.state = function() {
+              return copy(arc4, {});
+            };
+          }
+          if (is_math_call) {
+            math[rngname] = prng2;
+            return seed2;
+          } else return prng2;
+        })(
+          prng,
+          shortseed,
+          "global" in options ? options.global : this == math,
+          options.state
+        );
+      }
+      function ARC4(key) {
+        var t, keylen = key.length, me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
+        if (!keylen) {
+          key = [keylen++];
+        }
+        while (i < width) {
+          s[i] = i++;
+        }
+        for (i = 0; i < width; i++) {
+          s[i] = s[j = mask & j + key[i % keylen] + (t = s[i])];
+          s[j] = t;
+        }
+        (me.g = function(count) {
+          var t2, r = 0, i2 = me.i, j2 = me.j, s2 = me.S;
+          while (count--) {
+            t2 = s2[i2 = mask & i2 + 1];
+            r = r * width + s2[mask & (s2[i2] = s2[j2 = mask & j2 + t2]) + (s2[j2] = t2)];
+          }
+          me.i = i2;
+          me.j = j2;
+          return r;
+        })(width);
+      }
+      function copy(f, t) {
+        t.i = f.i;
+        t.j = f.j;
+        t.S = f.S.slice();
+        return t;
+      }
+      function flatten(obj, depth) {
+        var result = [], typ = typeof obj, prop;
+        if (depth && typ == "object") {
+          for (prop in obj) {
+            try {
+              result.push(flatten(obj[prop], depth - 1));
+            } catch (e) {
+            }
+          }
+        }
+        return result.length ? result : typ == "string" ? obj : obj + "\0";
+      }
+      function mixkey(seed, key) {
+        var stringseed = seed + "", smear, j = 0;
+        while (j < stringseed.length) {
+          key[mask & j] = mask & (smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++);
+        }
+        return tostring(key);
+      }
+      function autoseed() {
+        try {
+          var out;
+          if (nodecrypto && (out = nodecrypto.randomBytes)) {
+            out = out(width);
+          } else {
+            out = new Uint8Array(width);
+            (global.crypto || global.msCrypto).getRandomValues(out);
+          }
+          return tostring(out);
+        } catch (e) {
+          var browser = global.navigator, plugins = browser && browser.plugins;
+          return [+/* @__PURE__ */ new Date(), global, plugins, global.screen, tostring(pool)];
+        }
+      }
+      function tostring(a) {
+        return String.fromCharCode.apply(0, a);
+      }
+      mixkey(math.random(), pool);
+      if (module.exports) {
+        module.exports = seedrandom2;
+        try {
+          nodecrypto = require$$0;
+        } catch (ex) {
+        }
+      } else {
+        math["seed" + rngname] = seedrandom2;
+      }
+    })(
+      // global: `self` in browsers (including strict mode and web workers),
+      // otherwise `this` in Node and other environments
+      typeof self !== "undefined" ? self : seedrandom$2,
+      [],
+      // pool: entropy pool starts empty
+      Math
+      // math: package containing random, pow, and seedrandom
+    );
+  })(seedrandom$3);
+  return seedrandom$3.exports;
+}
+var seedrandom$1;
+var hasRequiredSeedrandom;
+function requireSeedrandom() {
+  if (hasRequiredSeedrandom) return seedrandom$1;
+  hasRequiredSeedrandom = 1;
+  var alea2 = requireAlea();
+  var xor1282 = requireXor128();
+  var xorwow2 = requireXorwow();
+  var xorshift72 = requireXorshift7();
+  var xor40962 = requireXor4096();
+  var tychei2 = requireTychei();
+  var sr = requireSeedrandom$1();
+  sr.alea = alea2;
+  sr.xor128 = xor1282;
+  sr.xorwow = xorwow2;
+  sr.xorshift7 = xorshift72;
+  sr.xor4096 = xor40962;
+  sr.tychei = tychei2;
+  seedrandom$1 = sr;
+  return seedrandom$1;
+}
+var seedrandomExports = requireSeedrandom();
+const seedrandom = /* @__PURE__ */ getDefaultExportFromCjs(seedrandomExports);
+const rngClass$3 = seedrandom.alea;
+function isSingleDocSource(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj.type === "singleDoc" && typeof typedObj.id === "string" && typeof typedObj.isDescription === "boolean" && typeof typedObj.doenetML === "string" && typeof typedObj.version === "string"
+  );
+}
+function isSingleDocStateNoSource(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj.type === "singleDoc" && typeof typedObj.id === "string" && (typedObj.parentId === null || typeof typedObj.parentId === "string") && typeof typedObj.initialVariant === "number" && typeof typedObj.creditAchieved === "number" && typeof typedObj.attemptNumber === "number" && typeof typedObj.currentVariant === "number" && Array.isArray(typedObj.previousVariants) && typedObj.previousVariants.every((x) => typeof x === "number") && typeof typedObj.initialQuestionCounter === "number" && (typedObj.restrictToVariantSlice === void 0 || isRestrictToVariantSlice(typedObj.restrictToVariantSlice))
+  );
+}
+function initializeSingleDocState({
+  source,
+  variant,
+  parentId,
+  restrictToVariantSlice
+}) {
+  const extendedId = source.id + (restrictToVariantSlice === void 0 ? "" : "|" + restrictToVariantSlice.idx.toString());
+  return {
+    type: "singleDoc",
+    id: extendedId,
+    parentId,
+    source,
+    initialVariant: variant,
+    creditAchieved: 0,
+    attemptNumber: 0,
+    currentVariant: 0,
+    previousVariants: [],
+    initialQuestionCounter: 0,
+    doenetStateIdx: null,
+    restrictToVariantSlice
+  };
+}
+function generateNewSingleDocAttempt({
+  state,
+  numActivityVariants,
+  initialQuestionCounter,
+  parentAttempt
+}) {
+  const previousVariants = state.previousVariants;
+  const numVariants = calcNumVariantsFromState(state, numActivityVariants);
+  const numPrevVariants = previousVariants.length;
+  const numVariantsToExclude = numPrevVariants % numVariants;
+  const numVariantOptions = numVariants - numVariantsToExclude;
+  const variantsToExclude = previousVariants.slice(numPrevVariants - numVariantsToExclude, numPrevVariants).sort((a, b) => a - b);
+  const rngSeed = state.initialVariant.toString() + "|" + state.id.toString() + "|" + state.attemptNumber.toString() + "|" + parentAttempt.toString();
+  const rng = rngClass$3(rngSeed);
+  let selectedVariant = Math.floor(rng() * numVariantOptions) + 1;
+  for (const excludedVariant of variantsToExclude) {
+    if (selectedVariant >= excludedVariant) {
+      selectedVariant++;
+    }
+  }
+  if (state.restrictToVariantSlice) {
+    selectedVariant = (selectedVariant - 1) * state.restrictToVariantSlice.numSlices + state.restrictToVariantSlice.idx;
+  }
+  const finalQuestionCounter = initialQuestionCounter + (state.source.isDescription ? 0 : 1);
+  const newState = {
+    ...state,
+    creditAchieved: 0,
+    attemptNumber: state.attemptNumber + 1,
+    currentVariant: selectedVariant,
+    previousVariants: [...state.previousVariants, selectedVariant],
+    doenetStateIdx: null,
+    initialQuestionCounter
+  };
+  return { finalQuestionCounter, state: newState };
+}
+function extractSingleDocItemCredit(activityState, nPrevInShuffleOrder = 0) {
+  if (activityState.source.isDescription) {
+    return [];
+  } else {
+    return [
+      {
+        id: activityState.id,
+        score: activityState.creditAchieved,
+        docId: activityState.id,
+        shuffledOrder: nPrevInShuffleOrder + 1,
+        variant: activityState.currentVariant
+      }
+    ];
+  }
+}
+function pruneSingleDocStateForSave(activityState) {
+  const { source: _source, ...newState } = { ...activityState };
+  return newState;
+}
+function addSourceToSingleDocState(activityState, source) {
+  return { ...activityState, source };
+}
+const rngClass$2 = seedrandom.alea;
+function isSelectSource(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj.type === "select" && typeof typedObj.id === "string" && typeof typedObj.numToSelect === "number" && typeof typedObj.selectByVariant === "boolean" && Array.isArray(typedObj.items) && typedObj.items.every(isActivitySource)
+  );
+}
+function isSelectStateNoSource(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj.type === "select" && typeof typedObj.id === "string" && (typedObj.parentId === null || typeof typedObj.parentId === "string") && typeof typedObj.initialVariant === "number" && typeof typedObj.creditAchieved === "number" && Array.isArray(typedObj.allChildren) && typedObj.allChildren.every(isActivityStateNoSource) && typeof typedObj.attemptNumber === "number" && Array.isArray(typedObj.selectedChildren) && typedObj.selectedChildren.every(isActivityStateNoSource) && Array.isArray(typedObj.previousSelections) && typedObj.previousSelections.every((x) => typeof x === "string") && typeof typedObj.initialQuestionCounter === "number" && (typedObj.restrictToVariantSlice === void 0 || isRestrictToVariantSlice(typedObj.restrictToVariantSlice))
+  );
+}
+function initializeSelectState({
+  source,
+  variant,
+  parentId,
+  numActivityVariants,
+  restrictToVariantSlice
+}) {
+  const rngSeed = variant.toString() + "|" + source.id.toString();
+  const rng = rngClass$2(rngSeed);
+  const childStates = [];
+  const extendedId = source.id + (restrictToVariantSlice === void 0 ? "" : "|" + restrictToVariantSlice.idx.toString());
+  if (restrictToVariantSlice !== void 0) {
+    throw Error(
+      "A select inside a select-multiple has not yet been implemented."
+    );
+  }
+  if (source.numToSelect === 1 || !source.selectByVariant) {
+    for (const activitySource of source.items) {
+      const childVariant = Math.floor(rng() * 1e6);
+      childStates.push(
+        initializeActivityState({
+          source: activitySource,
+          variant: childVariant,
+          parentId: extendedId,
+          numActivityVariants
+        })
+      );
+    }
+  } else {
+    for (const activitySource of source.items) {
+      const childVariant = Math.floor(rng() * 1e6) + 1;
+      const numVariants = calcNumVariants(
+        activitySource,
+        numActivityVariants
+      );
+      for (let idx = 1; idx <= numVariants; idx++) {
+        childStates.push(
+          initializeActivityState({
+            source: activitySource,
+            variant: childVariant,
+            parentId: extendedId,
+            numActivityVariants,
+            // If `numVariants` is actually the number of variants,
+            // this restrictions creates a slice of just one variant.
+            // Otherwise, the slice may still contain multiple variants,
+            // but they at least will not overlap with other slices.
+            restrictToVariantSlice: { idx, numSlices: numVariants }
+          })
+        );
+      }
+    }
+  }
+  return {
+    type: "select",
+    id: extendedId,
+    parentId,
+    source,
+    initialVariant: variant,
+    creditAchieved: 0,
+    allChildren: childStates,
+    attemptNumber: 0,
+    selectedChildren: [],
+    previousSelections: [],
+    initialQuestionCounter: 0,
+    restrictToVariantSlice
+  };
+}
+function generateNewSelectAttempt({
+  state,
+  numActivityVariants,
+  initialQuestionCounter,
+  parentAttempt
+}) {
+  const source = state.source;
+  const numToSelect = source.numToSelect;
+  const numChildren = state.allChildren.length;
+  if (numChildren === 0) {
+    return { finalQuestionCounter: initialQuestionCounter, state };
+  }
+  const numVariantsPerChild = state.allChildren.map(
+    (a) => calcNumVariantsFromState(a, numActivityVariants)
+  );
+  const totalNumOptions = source.selectByVariant ? numVariantsPerChild.reduce((a, c) => a + c) : numChildren;
+  if (numToSelect > totalNumOptions) {
+    if (source.selectByVariant) {
+      throw Error(
+        `For a select activity, "number to select" is ${numToSelect.toString()}, which is larger than the number of available variants (${totalNumOptions.toString()}).`
+      );
+    } else {
+      const totalNumChildVariants = numVariantsPerChild.reduce(
+        (a, c) => a + c
+      );
+      if (numToSelect > totalNumChildVariants) {
+        throw Error(
+          `For a select activity, "number to select" is ${numToSelect.toString()}, which is larger than the number of available activities (${totalNumOptions.toString()}).`
+        );
+      } else {
+        throw Error(
+          `For a select activity, "number to select" is ${numToSelect.toString()}, which is larger than the number of available activities (${totalNumOptions.toString()}). (Turning on "select by variant" will add enough options for the select activity to function.)`
+        );
+      }
+    }
+  }
+  const childIdToIdx = {};
+  for (const [idx, child] of state.allChildren.entries()) {
+    childIdToIdx[child.id] = idx;
+  }
+  const numPrevSelected = numToSelect * state.attemptNumber;
+  const numInGroup = numPrevSelected % totalNumOptions;
+  const numLeftInGroup = totalNumOptions - numInGroup;
+  const childCountsInGroup = Array(numChildren).fill(0);
+  for (const childId of [...state.previousSelections].reverse().slice(0, numInGroup)) {
+    childCountsInGroup[childIdToIdx[childId]]++;
+  }
+  const childOptionsLeft = childCountsInGroup.flatMap((cnt, idx) => {
+    if (source.selectByVariant) {
+      return Array(numVariantsPerChild[idx] - cnt).fill(idx);
+    } else {
+      if (cnt) {
+        return [];
+      } else {
+        return [idx];
+      }
+    }
+  });
+  if (childOptionsLeft.length !== numLeftInGroup) {
+    throw Error("we did something wrong");
+  }
+  const rngSeed = state.initialVariant.toString() + "|" + state.id.toString() + "|" + state.attemptNumber.toString() + "|" + parentAttempt.toString();
+  const rng = rngClass$2(rngSeed);
+  const childrenChosen = [];
+  for (let i = 0; i < Math.min(numToSelect, numLeftInGroup); i++) {
+    const idx = Math.floor(rng() * childOptionsLeft.length);
+    const newChildInd = childOptionsLeft.splice(idx, 1)[0];
+    childrenChosen.push(newChildInd);
+  }
+  if (numToSelect > numLeftInGroup) {
+    const nextChildOptions = childCountsInGroup.flatMap((cnt, idx) => {
+      if (source.selectByVariant) {
+        return Array(cnt).fill(idx);
+      } else {
+        if (cnt) {
+          return [idx];
+        } else {
+          return [];
+        }
+      }
+    });
+    for (let i = 0; i < numToSelect - numLeftInGroup; i++) {
+      const idx = Math.floor(rng() * nextChildOptions.length);
+      const newChildInd = nextChildOptions.splice(idx, 1)[0];
+      childrenChosen.push(newChildInd);
+    }
+  }
+  const newActivityStates = [];
+  const newActivityOptionStates = [...state.allChildren];
+  let questionCounter = initialQuestionCounter;
+  for (const childIdx of childrenChosen) {
+    const { finalQuestionCounter: endCounter, state: newState2 } = generateNewActivityAttempt({
+      state: newActivityOptionStates[childIdx],
+      numActivityVariants,
+      initialQuestionCounter: questionCounter,
+      parentAttempt: state.attemptNumber + 1
+    });
+    questionCounter = endCounter;
+    newActivityOptionStates[childIdx] = newState2;
+    newActivityStates.push(newState2);
+  }
+  const newState = {
+    ...state,
+    creditAchieved: 0,
+    allChildren: newActivityOptionStates,
+    attemptNumber: state.attemptNumber + 1,
+    selectedChildren: newActivityStates,
+    previousSelections: [
+      ...state.previousSelections,
+      ...newActivityStates.map((s) => s.id)
+    ],
+    initialQuestionCounter
+  };
+  return { finalQuestionCounter: questionCounter, state: newState };
+}
+function generateNewSingleDocAttemptForMultiSelect({
+  state,
+  numActivityVariants,
+  initialQuestionCounter,
+  parentAttempt,
+  childId
+}) {
+  const source = state.source;
+  const numToSelect = source.numToSelect;
+  if (numToSelect === 1 || state.attemptNumber === 0) {
+    throw Error(
+      "no reason to call when selecting just one item or for first attempt"
+    );
+  }
+  const numChildren = state.allChildren.length;
+  const childIdToIdx = {};
+  for (const [idx, child] of state.allChildren.entries()) {
+    childIdToIdx[child.id] = idx;
+  }
+  const otherSelectedIds = state.selectedChildren.filter((a) => a.id !== childId).map((a) => a.id);
+  if (otherSelectedIds.length !== numToSelect - 1) {
+    throw Error("We made a miscalculation");
+  }
+  const idOptions = state.allChildren.map((s) => s.id).filter((id) => !otherSelectedIds.includes(id));
+  const numOptions = idOptions.length;
+  const prevSelectionOfOptions = state.previousSelections.filter(
+    (id) => !otherSelectedIds.includes(id)
+  );
+  const numPrevSelections = prevSelectionOfOptions.length;
+  const numInGroup = numPrevSelections % numOptions;
+  const additionalExcludes = prevSelectionOfOptions.slice(
+    numPrevSelections - numInGroup,
+    numPrevSelections
+  );
+  const idxOfAllExcluded = [...otherSelectedIds, ...additionalExcludes].map((id) => childIdToIdx[id]).sort((a, b) => a - b);
+  const slotNum = state.selectedChildren.map((a) => a.id).indexOf(childId);
+  const rngSeed = state.initialVariant.toString() + "|" + state.id.toString() + "|" + state.attemptNumber.toString() + "|" + parentAttempt.toString();
+  const rng = rngClass$2(rngSeed);
+  let selectedIdx = Math.floor(
+    rng() * (numChildren - idxOfAllExcluded.length)
+  );
+  for (const excludedIdx of idxOfAllExcluded) {
+    if (selectedIdx >= excludedIdx) {
+      selectedIdx++;
+    }
+  }
+  const newActivityStates = [...state.selectedChildren];
+  const newActivityOptionStates = [...state.allChildren];
+  const { finalQuestionCounter, state: newChildState } = generateNewActivityAttempt({
+    state: newActivityOptionStates[selectedIdx],
+    numActivityVariants,
+    initialQuestionCounter,
+    parentAttempt: state.attemptNumber + 1
+  });
+  newActivityOptionStates[selectedIdx] = newChildState;
+  newActivityStates[slotNum] = newChildState;
+  const latestOtherCreditAchieved = state.selectedChildren.filter((_, i) => i != slotNum).map((a) => a.creditAchieved);
+  const creditAchieved = latestOtherCreditAchieved.reduce((a, c) => a + c, 0) / state.selectedChildren.length;
+  const newState = {
+    ...state,
+    allChildren: newActivityOptionStates,
+    selectedChildren: newActivityStates,
+    creditAchieved,
+    previousSelections: [...state.previousSelections, newChildState.id],
+    initialQuestionCounter
+  };
+  return { finalQuestionCounter, state: newState };
+}
+function extractSelectItemCredit(activityState, nPrevInShuffleOrder = 0) {
+  if (activityState.attemptNumber === 0) {
+    const nChildren = activityState.allChildren.length;
+    if (nChildren === 0) {
+      return [];
+    }
+    const results = [];
+    let nPrev = nPrevInShuffleOrder;
+    for (let i = 0; i < activityState.source.numToSelect; i++) {
+      const childState = activityState.allChildren[i % nChildren];
+      const next = extractActivityItemCredit(childState, nPrev);
+      nPrev += next.length;
+      results.push(...next);
+    }
+    return results;
+  }
+  if (activityState.source.numToSelect === 1 && activityState.allChildren.every((child) => child.type === "singleDoc")) {
+    return [
+      {
+        id: activityState.id,
+        score: activityState.creditAchieved,
+        docId: activityState.selectedChildren[0].id,
+        shuffledOrder: nPrevInShuffleOrder + 1,
+        variant: activityState.selectedChildren[0].currentVariant
+      }
+    ];
+  } else {
+    let nPrev = nPrevInShuffleOrder;
+    return activityState.selectedChildren.flatMap((state) => {
+      const next = extractActivityItemCredit(state, nPrev);
+      nPrev += next.length;
+      return next;
+    });
+  }
+}
+function pruneSelectStateForSave(activityState) {
+  const { source: _source, ...newState } = { ...activityState };
+  const allChildren = newState.allChildren.map(
+    (child) => pruneActivityStateForSave(child)
+  );
+  const selectedChildren = newState.selectedChildren.map(
+    (child) => pruneActivityStateForSave(child)
+  );
+  return { ...newState, allChildren, selectedChildren };
+}
+function addSourceToSelectState(activityState, source) {
+  const allChildren = activityState.allChildren.map((child) => {
+    const idx = source.items.findIndex(
+      (src) => src.id === extractSourceId(child.id)
+    );
+    return addSourceToActivityState(child, source.items[idx]);
+  });
+  const selectedChildren = activityState.selectedChildren.map((child) => {
+    const idx = source.items.findIndex(
+      (src) => src.id === extractSourceId(child.id)
+    );
+    return addSourceToActivityState(child, source.items[idx]);
+  });
+  return {
+    ...activityState,
+    source,
+    allChildren,
+    selectedChildren
+  };
+}
+function calcNumVariantsSelect(source, numActivityVariants) {
+  const numVariantsTot = source.items.reduce(
+    (a, c) => a + calcNumVariants(c, numActivityVariants),
+    0
+  );
+  return Math.floor(numVariantsTot / source.numToSelect);
+}
+function getNumItemsInSelect(source) {
+  if (source.items.length === 0) {
+    return 0;
+  }
+  const numDocumentsPerItem = getNumItems(source.items[0]);
+  if (source.items.length > 1) {
+    for (const item of source.items.slice(1)) {
+      if (getNumItems(item) !== numDocumentsPerItem) {
+        throw Error(
+          "The case where a select has options with different numbers of documents is not implemented"
+        );
+      }
+    }
+  }
+  return source.numToSelect * numDocumentsPerItem;
+}
+const rngClass$1 = seedrandom.alea;
+function isSequenceSource(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj.type === "sequence" && typeof typedObj.id === "string" && Array.isArray(typedObj.items) && typedObj.items.every(isActivitySource) && typeof typedObj.shuffle === "boolean" && (typedObj.creditWeights === void 0 || Array.isArray(typedObj.creditWeights) && typedObj.creditWeights.every(
+      (weight) => typeof weight === "number"
+    ))
+  );
+}
+function isSequenceStateNoSource(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj.type === "sequence" && typeof typedObj.id === "string" && (typedObj.parentId === null || typeof typedObj.parentId === "string") && typeof typedObj.initialVariant === "number" && typeof typedObj.creditAchieved === "number" && Array.isArray(typedObj.allChildren) && typedObj.allChildren.every(isActivityStateNoSource) && typeof typedObj.attemptNumber === "number" && Array.isArray(typedObj.orderedChildren) && typedObj.orderedChildren.every(isActivityStateNoSource) && (typedObj.restrictToVariantSlice === void 0 || isRestrictToVariantSlice(typedObj.restrictToVariantSlice))
+  );
+}
+function initializeSequenceState({
+  source,
+  variant,
+  parentId,
+  numActivityVariants,
+  restrictToVariantSlice
+}) {
+  const rngSeed = variant.toString() + "|" + source.id.toString();
+  const rng = rngClass$1(rngSeed);
+  const extendedId = source.id + (restrictToVariantSlice === void 0 ? "" : "|" + restrictToVariantSlice.idx.toString());
+  const childStates = source.items.map((activitySource) => {
+    const childVariant = Math.floor(rng() * 1e6);
+    return initializeActivityState({
+      source: activitySource,
+      variant: childVariant,
+      parentId: extendedId,
+      numActivityVariants,
+      restrictToVariantSlice
+    });
+  });
+  return {
+    type: "sequence",
+    id: extendedId,
+    parentId,
+    source,
+    initialVariant: variant,
+    creditAchieved: 0,
+    allChildren: childStates,
+    attemptNumber: 0,
+    orderedChildren: [],
+    restrictToVariantSlice
+  };
+}
+function generateNewSequenceAttempt({
+  state,
+  numActivityVariants,
+  initialQuestionCounter,
+  parentAttempt
+}) {
+  const source = state.source;
+  const childOrder = state.allChildren.map((state2) => state2.id);
+  if (source.shuffle) {
+    let shuffle_ids = function(arr, startInd2, numItems) {
+      for (let i = numItems - 1; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        [arr[startInd2 + i], arr[startInd2 + j]] = [
+          arr[startInd2 + j],
+          arr[startInd2 + i]
+        ];
+      }
+    };
+    const rngSeed = state.initialVariant.toString() + "|" + state.id.toString() + "|" + state.attemptNumber.toString() + "|" + parentAttempt.toString();
+    const rng = rngClass$1(rngSeed);
+    let startInd = 0;
+    while (startInd < state.allChildren.length) {
+      while (state.allChildren[startInd]?.type === "singleDoc" && state.allChildren[startInd].source.isDescription) {
+        startInd++;
+      }
+      if (startInd >= state.allChildren.length) {
+        break;
+      }
+      let numItems = 1;
+      while (state.allChildren[startInd + numItems] && (state.allChildren[startInd + numItems].type !== "singleDoc" || !state.allChildren[startInd + numItems].source.isDescription)) {
+        numItems++;
+      }
+      if (numItems > 1) {
+        shuffle_ids(childOrder, startInd, numItems);
+      }
+      startInd += numItems;
+    }
+  }
+  const orderedChildStates = [];
+  const unorderedChildStates = [...state.allChildren];
+  let questionCounter = initialQuestionCounter;
+  for (const childId of childOrder) {
+    const childIdx = state.allChildren.findIndex(
+      (child) => child.id === childId
+    );
+    const originalState = state.allChildren[childIdx];
+    const { finalQuestionCounter: endCounter, state: newState2 } = generateNewActivityAttempt({
+      state: originalState,
+      numActivityVariants,
+      initialQuestionCounter: questionCounter,
+      parentAttempt: state.attemptNumber + 1
+    });
+    questionCounter = endCounter;
+    orderedChildStates.push(newState2);
+    unorderedChildStates[childIdx] = newState2;
+  }
+  const newState = {
+    ...state,
+    creditAchieved: 0,
+    allChildren: unorderedChildStates,
+    attemptNumber: state.attemptNumber + 1,
+    orderedChildren: orderedChildStates
+  };
+  return { finalQuestionCounter: questionCounter, state: newState };
+}
+function extractSequenceItemCredit(activityState, nPrevInShuffleOrder = 0) {
+  if (activityState.attemptNumber === 0) {
+    let nPrev = nPrevInShuffleOrder;
+    return activityState.allChildren.flatMap((state) => {
+      const next = extractActivityItemCredit(state, nPrev);
+      nPrev += next.length;
+      return next;
+    });
+  } else {
+    let nPrev = nPrevInShuffleOrder;
+    const inShuffledOrder = activityState.orderedChildren.map((state) => {
+      const next = extractActivityItemCredit(state, nPrev);
+      nPrev += next.length;
+      return { childId: state.id, items: next };
+    });
+    const inOriginalOrder = activityState.allChildren.flatMap((state) => {
+      const childResults = inShuffledOrder.find(
+        (obj) => obj.childId === state.id
+      );
+      if (!childResults) {
+        throw Error("Unreachable");
+      }
+      return childResults.items;
+    });
+    return inOriginalOrder;
+  }
+}
+function pruneSequenceStateForSave(activityState) {
+  const { source: _source, ...newState } = { ...activityState };
+  const allChildren = newState.allChildren.map(
+    (child) => pruneActivityStateForSave(child)
+  );
+  const orderedChildren = newState.orderedChildren.map(
+    (child) => pruneActivityStateForSave(child)
+  );
+  return { ...newState, allChildren, orderedChildren };
+}
+function addSourceToSequenceState(activityState, source) {
+  const allChildren = activityState.allChildren.map((child) => {
+    const idx = source.items.findIndex(
+      (src) => src.id === extractSourceId(child.id)
+    );
+    return addSourceToActivityState(child, source.items[idx]);
+  });
+  const orderedChildren = activityState.orderedChildren.map((child) => {
+    const idx = source.items.findIndex(
+      (src) => src.id === extractSourceId(child.id)
+    );
+    return addSourceToActivityState(child, source.items[idx]);
+  });
+  return {
+    ...activityState,
+    source,
+    allChildren,
+    orderedChildren
+  };
+}
+function calcNumVariantsSequence(source, numActivityVariants) {
+  if (source.items.length === 0) {
+    return 0;
+  }
+  let numVariants = Infinity;
+  for (const item of source.items) {
+    numVariants = Math.min(
+      numVariants,
+      calcNumVariants(item, numActivityVariants)
+    );
+  }
+  return numVariants;
+}
+function getNumItemsInSequence(source) {
+  const numDocumentsForEachItem = source.items.map(getNumItems);
+  const totalNumDocuments = numDocumentsForEachItem.reduce(
+    (a, c) => a + c,
+    0
+  );
+  return totalNumDocuments;
+}
+function commonjsRequire(path) {
+  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+var object_hash = { exports: {} };
+var hasRequiredObject_hash;
+function requireObject_hash() {
+  if (hasRequiredObject_hash) return object_hash.exports;
+  hasRequiredObject_hash = 1;
+  (function(module, exports) {
+    !function(e) {
+      module.exports = e();
+    }(function() {
+      return function r(o, i, u) {
+        function s(n, e2) {
+          if (!i[n]) {
+            if (!o[n]) {
+              var t = "function" == typeof commonjsRequire && commonjsRequire;
+              if (!e2 && t) return t(n, true);
+              if (a) return a(n, true);
+              throw new Error("Cannot find module '" + n + "'");
+            }
+            e2 = i[n] = { exports: {} };
+            o[n][0].call(e2.exports, function(e3) {
+              var t2 = o[n][1][e3];
+              return s(t2 || e3);
+            }, e2, e2.exports, r, o, i, u);
+          }
+          return i[n].exports;
+        }
+        for (var a = "function" == typeof commonjsRequire && commonjsRequire, e = 0; e < u.length; e++) s(u[e]);
+        return s;
+      }({ 1: [function(w, b, m) {
+        !(function(e, n, s, c, d, h, p, g, y) {
+          var r = w("crypto");
+          function t(e2, t2) {
+            t2 = u(e2, t2);
+            var n2;
+            return void 0 === (n2 = "passthrough" !== t2.algorithm ? r.createHash(t2.algorithm) : new l()).write && (n2.write = n2.update, n2.end = n2.update), f(t2, n2).dispatch(e2), n2.update || n2.end(""), n2.digest ? n2.digest("buffer" === t2.encoding ? void 0 : t2.encoding) : (e2 = n2.read(), "buffer" !== t2.encoding ? e2.toString(t2.encoding) : e2);
+          }
+          (m = b.exports = t).sha1 = function(e2) {
+            return t(e2);
+          }, m.keys = function(e2) {
+            return t(e2, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
+          }, m.MD5 = function(e2) {
+            return t(e2, { algorithm: "md5", encoding: "hex" });
+          }, m.keysMD5 = function(e2) {
+            return t(e2, { algorithm: "md5", encoding: "hex", excludeValues: true });
+          };
+          var o = r.getHashes ? r.getHashes().slice() : ["sha1", "md5"], i = (o.push("passthrough"), ["buffer", "hex", "binary", "base64"]);
+          function u(e2, t2) {
+            var n2 = {};
+            if (n2.algorithm = (t2 = t2 || {}).algorithm || "sha1", n2.encoding = t2.encoding || "hex", n2.excludeValues = !!t2.excludeValues, n2.algorithm = n2.algorithm.toLowerCase(), n2.encoding = n2.encoding.toLowerCase(), n2.ignoreUnknown = true === t2.ignoreUnknown, n2.respectType = false !== t2.respectType, n2.respectFunctionNames = false !== t2.respectFunctionNames, n2.respectFunctionProperties = false !== t2.respectFunctionProperties, n2.unorderedArrays = true === t2.unorderedArrays, n2.unorderedSets = false !== t2.unorderedSets, n2.unorderedObjects = false !== t2.unorderedObjects, n2.replacer = t2.replacer || void 0, n2.excludeKeys = t2.excludeKeys || void 0, void 0 === e2) throw new Error("Object argument required.");
+            for (var r2 = 0; r2 < o.length; ++r2) o[r2].toLowerCase() === n2.algorithm.toLowerCase() && (n2.algorithm = o[r2]);
+            if (-1 === o.indexOf(n2.algorithm)) throw new Error('Algorithm "' + n2.algorithm + '"  not supported. supported values: ' + o.join(", "));
+            if (-1 === i.indexOf(n2.encoding) && "passthrough" !== n2.algorithm) throw new Error('Encoding "' + n2.encoding + '"  not supported. supported values: ' + i.join(", "));
+            return n2;
+          }
+          function a(e2) {
+            if ("function" == typeof e2) return null != /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i.exec(Function.prototype.toString.call(e2));
+          }
+          function f(o2, t2, i2) {
+            i2 = i2 || [];
+            function u2(e2) {
+              return t2.update ? t2.update(e2, "utf8") : t2.write(e2, "utf8");
+            }
+            return { dispatch: function(e2) {
+              return this["_" + (null === (e2 = o2.replacer ? o2.replacer(e2) : e2) ? "null" : typeof e2)](e2);
+            }, _object: function(t3) {
+              var n2, e2 = Object.prototype.toString.call(t3), r2 = /\[object (.*)\]/i.exec(e2);
+              r2 = (r2 = r2 ? r2[1] : "unknown:[" + e2 + "]").toLowerCase();
+              if (0 <= (e2 = i2.indexOf(t3))) return this.dispatch("[CIRCULAR:" + e2 + "]");
+              if (i2.push(t3), void 0 !== s && s.isBuffer && s.isBuffer(t3)) return u2("buffer:"), u2(t3);
+              if ("object" === r2 || "function" === r2 || "asyncfunction" === r2) return e2 = Object.keys(t3), o2.unorderedObjects && (e2 = e2.sort()), false === o2.respectType || a(t3) || e2.splice(0, 0, "prototype", "__proto__", "constructor"), o2.excludeKeys && (e2 = e2.filter(function(e3) {
+                return !o2.excludeKeys(e3);
+              })), u2("object:" + e2.length + ":"), n2 = this, e2.forEach(function(e3) {
+                n2.dispatch(e3), u2(":"), o2.excludeValues || n2.dispatch(t3[e3]), u2(",");
+              });
+              if (!this["_" + r2]) {
+                if (o2.ignoreUnknown) return u2("[" + r2 + "]");
+                throw new Error('Unknown object type "' + r2 + '"');
+              }
+              this["_" + r2](t3);
+            }, _array: function(e2, t3) {
+              t3 = void 0 !== t3 ? t3 : false !== o2.unorderedArrays;
+              var n2 = this;
+              if (u2("array:" + e2.length + ":"), !t3 || e2.length <= 1) return e2.forEach(function(e3) {
+                return n2.dispatch(e3);
+              });
+              var r2 = [], t3 = e2.map(function(e3) {
+                var t4 = new l(), n3 = i2.slice();
+                return f(o2, t4, n3).dispatch(e3), r2 = r2.concat(n3.slice(i2.length)), t4.read().toString();
+              });
+              return i2 = i2.concat(r2), t3.sort(), this._array(t3, false);
+            }, _date: function(e2) {
+              return u2("date:" + e2.toJSON());
+            }, _symbol: function(e2) {
+              return u2("symbol:" + e2.toString());
+            }, _error: function(e2) {
+              return u2("error:" + e2.toString());
+            }, _boolean: function(e2) {
+              return u2("bool:" + e2.toString());
+            }, _string: function(e2) {
+              u2("string:" + e2.length + ":"), u2(e2.toString());
+            }, _function: function(e2) {
+              u2("fn:"), a(e2) ? this.dispatch("[native]") : this.dispatch(e2.toString()), false !== o2.respectFunctionNames && this.dispatch("function-name:" + String(e2.name)), o2.respectFunctionProperties && this._object(e2);
+            }, _number: function(e2) {
+              return u2("number:" + e2.toString());
+            }, _xml: function(e2) {
+              return u2("xml:" + e2.toString());
+            }, _null: function() {
+              return u2("Null");
+            }, _undefined: function() {
+              return u2("Undefined");
+            }, _regexp: function(e2) {
+              return u2("regex:" + e2.toString());
+            }, _uint8array: function(e2) {
+              return u2("uint8array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _uint8clampedarray: function(e2) {
+              return u2("uint8clampedarray:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _int8array: function(e2) {
+              return u2("int8array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _uint16array: function(e2) {
+              return u2("uint16array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _int16array: function(e2) {
+              return u2("int16array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _uint32array: function(e2) {
+              return u2("uint32array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _int32array: function(e2) {
+              return u2("int32array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _float32array: function(e2) {
+              return u2("float32array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _float64array: function(e2) {
+              return u2("float64array:"), this.dispatch(Array.prototype.slice.call(e2));
+            }, _arraybuffer: function(e2) {
+              return u2("arraybuffer:"), this.dispatch(new Uint8Array(e2));
+            }, _url: function(e2) {
+              return u2("url:" + e2.toString());
+            }, _map: function(e2) {
+              u2("map:");
+              e2 = Array.from(e2);
+              return this._array(e2, false !== o2.unorderedSets);
+            }, _set: function(e2) {
+              u2("set:");
+              e2 = Array.from(e2);
+              return this._array(e2, false !== o2.unorderedSets);
+            }, _file: function(e2) {
+              return u2("file:"), this.dispatch([e2.name, e2.size, e2.type, e2.lastModfied]);
+            }, _blob: function() {
+              if (o2.ignoreUnknown) return u2("[blob]");
+              throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
+            }, _domwindow: function() {
+              return u2("domwindow");
+            }, _bigint: function(e2) {
+              return u2("bigint:" + e2.toString());
+            }, _process: function() {
+              return u2("process");
+            }, _timer: function() {
+              return u2("timer");
+            }, _pipe: function() {
+              return u2("pipe");
+            }, _tcp: function() {
+              return u2("tcp");
+            }, _udp: function() {
+              return u2("udp");
+            }, _tty: function() {
+              return u2("tty");
+            }, _statwatcher: function() {
+              return u2("statwatcher");
+            }, _securecontext: function() {
+              return u2("securecontext");
+            }, _connection: function() {
+              return u2("connection");
+            }, _zlib: function() {
+              return u2("zlib");
+            }, _context: function() {
+              return u2("context");
+            }, _nodescript: function() {
+              return u2("nodescript");
+            }, _httpparser: function() {
+              return u2("httpparser");
+            }, _dataview: function() {
+              return u2("dataview");
+            }, _signal: function() {
+              return u2("signal");
+            }, _fsevent: function() {
+              return u2("fsevent");
+            }, _tlswrap: function() {
+              return u2("tlswrap");
+            } };
+          }
+          function l() {
+            return { buf: "", write: function(e2) {
+              this.buf += e2;
+            }, end: function(e2) {
+              this.buf += e2;
+            }, read: function() {
+              return this.buf;
+            } };
+          }
+          m.writeToStream = function(e2, t2, n2) {
+            return void 0 === n2 && (n2 = t2, t2 = {}), f(t2 = u(e2, t2), n2).dispatch(e2);
+          };
+        }).call(this, w("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, w("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/fake_9a5aa49d.js", "/");
+      }, { buffer: 3, crypto: 5, lYpoI2: 11 }], 2: [function(e, t, f) {
+        !(function(e2, t2, n, r, o, i, u, s, a) {
+          !function(e3) {
+            var a2 = "undefined" != typeof Uint8Array ? Uint8Array : Array, t3 = "+".charCodeAt(0), n2 = "/".charCodeAt(0), r2 = "0".charCodeAt(0), o2 = "a".charCodeAt(0), i2 = "A".charCodeAt(0), u2 = "-".charCodeAt(0), s2 = "_".charCodeAt(0);
+            function f2(e4) {
+              e4 = e4.charCodeAt(0);
+              return e4 === t3 || e4 === u2 ? 62 : e4 === n2 || e4 === s2 ? 63 : e4 < r2 ? -1 : e4 < r2 + 10 ? e4 - r2 + 26 + 26 : e4 < i2 + 26 ? e4 - i2 : e4 < o2 + 26 ? e4 - o2 + 26 : void 0;
+            }
+            e3.toByteArray = function(e4) {
+              var t4, n3;
+              if (0 < e4.length % 4) throw new Error("Invalid string. Length must be a multiple of 4");
+              var r3 = e4.length, r3 = "=" === e4.charAt(r3 - 2) ? 2 : "=" === e4.charAt(r3 - 1) ? 1 : 0, o3 = new a2(3 * e4.length / 4 - r3), i3 = 0 < r3 ? e4.length - 4 : e4.length, u3 = 0;
+              function s3(e5) {
+                o3[u3++] = e5;
+              }
+              for (t4 = 0; t4 < i3; t4 += 4, 0) s3((16711680 & (n3 = f2(e4.charAt(t4)) << 18 | f2(e4.charAt(t4 + 1)) << 12 | f2(e4.charAt(t4 + 2)) << 6 | f2(e4.charAt(t4 + 3)))) >> 16), s3((65280 & n3) >> 8), s3(255 & n3);
+              return 2 == r3 ? s3(255 & (n3 = f2(e4.charAt(t4)) << 2 | f2(e4.charAt(t4 + 1)) >> 4)) : 1 == r3 && (s3((n3 = f2(e4.charAt(t4)) << 10 | f2(e4.charAt(t4 + 1)) << 4 | f2(e4.charAt(t4 + 2)) >> 2) >> 8 & 255), s3(255 & n3)), o3;
+            }, e3.fromByteArray = function(e4) {
+              var t4, n3, r3, o3, i3 = e4.length % 3, u3 = "";
+              function s3(e5) {
+                return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(e5);
+              }
+              for (t4 = 0, r3 = e4.length - i3; t4 < r3; t4 += 3) n3 = (e4[t4] << 16) + (e4[t4 + 1] << 8) + e4[t4 + 2], u3 += s3((o3 = n3) >> 18 & 63) + s3(o3 >> 12 & 63) + s3(o3 >> 6 & 63) + s3(63 & o3);
+              switch (i3) {
+                case 1:
+                  u3 = (u3 += s3((n3 = e4[e4.length - 1]) >> 2)) + s3(n3 << 4 & 63) + "==";
+                  break;
+                case 2:
+                  u3 = (u3 = (u3 += s3((n3 = (e4[e4.length - 2] << 8) + e4[e4.length - 1]) >> 10)) + s3(n3 >> 4 & 63)) + s3(n3 << 2 & 63) + "=";
+              }
+              return u3;
+            };
+          }(void 0 === f ? this.base64js = {} : f);
+        }).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/base64-js/lib/b64.js", "/node_modules/gulp-browserify/node_modules/base64-js/lib");
+      }, { buffer: 3, lYpoI2: 11 }], 3: [function(O, e, H) {
+        !(function(e2, n, f, r, h, p, g, y, w) {
+          var a = O("base64-js"), i = O("ieee754");
+          function f(e3, t2, n2) {
+            if (!(this instanceof f)) return new f(e3, t2, n2);
+            var r2, o2, i2, u2, s2 = typeof e3;
+            if ("base64" === t2 && "string" == s2) for (e3 = (u2 = e3).trim ? u2.trim() : u2.replace(/^\s+|\s+$/g, ""); e3.length % 4 != 0; ) e3 += "=";
+            if ("number" == s2) r2 = j(e3);
+            else if ("string" == s2) r2 = f.byteLength(e3, t2);
+            else {
+              if ("object" != s2) throw new Error("First argument needs to be a number, array or string.");
+              r2 = j(e3.length);
+            }
+            if (f._useTypedArrays ? o2 = f._augment(new Uint8Array(r2)) : ((o2 = this).length = r2, o2._isBuffer = true), f._useTypedArrays && "number" == typeof e3.byteLength) o2._set(e3);
+            else if (C(u2 = e3) || f.isBuffer(u2) || u2 && "object" == typeof u2 && "number" == typeof u2.length) for (i2 = 0; i2 < r2; i2++) f.isBuffer(e3) ? o2[i2] = e3.readUInt8(i2) : o2[i2] = e3[i2];
+            else if ("string" == s2) o2.write(e3, 0, t2);
+            else if ("number" == s2 && !f._useTypedArrays && !n2) for (i2 = 0; i2 < r2; i2++) o2[i2] = 0;
+            return o2;
+          }
+          function b(e3, t2, n2, r2) {
+            return f._charsWritten = c(function(e4) {
+              for (var t3 = [], n3 = 0; n3 < e4.length; n3++) t3.push(255 & e4.charCodeAt(n3));
+              return t3;
+            }(t2), e3, n2, r2);
+          }
+          function m(e3, t2, n2, r2) {
+            return f._charsWritten = c(function(e4) {
+              for (var t3, n3, r3 = [], o2 = 0; o2 < e4.length; o2++) n3 = e4.charCodeAt(o2), t3 = n3 >> 8, n3 = n3 % 256, r3.push(n3), r3.push(t3);
+              return r3;
+            }(t2), e3, n2, r2);
+          }
+          function v(e3, t2, n2) {
+            var r2 = "";
+            n2 = Math.min(e3.length, n2);
+            for (var o2 = t2; o2 < n2; o2++) r2 += String.fromCharCode(e3[o2]);
+            return r2;
+          }
+          function o(e3, t2, n2, r2) {
+            r2 || (d("boolean" == typeof n2, "missing or invalid endian"), d(null != t2, "missing offset"), d(t2 + 1 < e3.length, "Trying to read beyond buffer length"));
+            var o2, r2 = e3.length;
+            if (!(r2 <= t2)) return n2 ? (o2 = e3[t2], t2 + 1 < r2 && (o2 |= e3[t2 + 1] << 8)) : (o2 = e3[t2] << 8, t2 + 1 < r2 && (o2 |= e3[t2 + 1])), o2;
+          }
+          function u(e3, t2, n2, r2) {
+            r2 || (d("boolean" == typeof n2, "missing or invalid endian"), d(null != t2, "missing offset"), d(t2 + 3 < e3.length, "Trying to read beyond buffer length"));
+            var o2, r2 = e3.length;
+            if (!(r2 <= t2)) return n2 ? (t2 + 2 < r2 && (o2 = e3[t2 + 2] << 16), t2 + 1 < r2 && (o2 |= e3[t2 + 1] << 8), o2 |= e3[t2], t2 + 3 < r2 && (o2 += e3[t2 + 3] << 24 >>> 0)) : (t2 + 1 < r2 && (o2 = e3[t2 + 1] << 16), t2 + 2 < r2 && (o2 |= e3[t2 + 2] << 8), t2 + 3 < r2 && (o2 |= e3[t2 + 3]), o2 += e3[t2] << 24 >>> 0), o2;
+          }
+          function _(e3, t2, n2, r2) {
+            if (r2 || (d("boolean" == typeof n2, "missing or invalid endian"), d(null != t2, "missing offset"), d(t2 + 1 < e3.length, "Trying to read beyond buffer length")), !(e3.length <= t2)) return r2 = o(e3, t2, n2, true), 32768 & r2 ? -1 * (65535 - r2 + 1) : r2;
+          }
+          function E(e3, t2, n2, r2) {
+            if (r2 || (d("boolean" == typeof n2, "missing or invalid endian"), d(null != t2, "missing offset"), d(t2 + 3 < e3.length, "Trying to read beyond buffer length")), !(e3.length <= t2)) return r2 = u(e3, t2, n2, true), 2147483648 & r2 ? -1 * (4294967295 - r2 + 1) : r2;
+          }
+          function I(e3, t2, n2, r2) {
+            return r2 || (d("boolean" == typeof n2, "missing or invalid endian"), d(t2 + 3 < e3.length, "Trying to read beyond buffer length")), i.read(e3, t2, n2, 23, 4);
+          }
+          function A(e3, t2, n2, r2) {
+            return r2 || (d("boolean" == typeof n2, "missing or invalid endian"), d(t2 + 7 < e3.length, "Trying to read beyond buffer length")), i.read(e3, t2, n2, 52, 8);
+          }
+          function s(e3, t2, n2, r2, o2) {
+            o2 || (d(null != t2, "missing value"), d("boolean" == typeof r2, "missing or invalid endian"), d(null != n2, "missing offset"), d(n2 + 1 < e3.length, "trying to write beyond buffer length"), Y(t2, 65535));
+            o2 = e3.length;
+            if (!(o2 <= n2)) for (var i2 = 0, u2 = Math.min(o2 - n2, 2); i2 < u2; i2++) e3[n2 + i2] = (t2 & 255 << 8 * (r2 ? i2 : 1 - i2)) >>> 8 * (r2 ? i2 : 1 - i2);
+          }
+          function l(e3, t2, n2, r2, o2) {
+            o2 || (d(null != t2, "missing value"), d("boolean" == typeof r2, "missing or invalid endian"), d(null != n2, "missing offset"), d(n2 + 3 < e3.length, "trying to write beyond buffer length"), Y(t2, 4294967295));
+            o2 = e3.length;
+            if (!(o2 <= n2)) for (var i2 = 0, u2 = Math.min(o2 - n2, 4); i2 < u2; i2++) e3[n2 + i2] = t2 >>> 8 * (r2 ? i2 : 3 - i2) & 255;
+          }
+          function B(e3, t2, n2, r2, o2) {
+            o2 || (d(null != t2, "missing value"), d("boolean" == typeof r2, "missing or invalid endian"), d(null != n2, "missing offset"), d(n2 + 1 < e3.length, "Trying to write beyond buffer length"), F(t2, 32767, -32768)), e3.length <= n2 || s(e3, 0 <= t2 ? t2 : 65535 + t2 + 1, n2, r2, o2);
+          }
+          function L(e3, t2, n2, r2, o2) {
+            o2 || (d(null != t2, "missing value"), d("boolean" == typeof r2, "missing or invalid endian"), d(null != n2, "missing offset"), d(n2 + 3 < e3.length, "Trying to write beyond buffer length"), F(t2, 2147483647, -2147483648)), e3.length <= n2 || l(e3, 0 <= t2 ? t2 : 4294967295 + t2 + 1, n2, r2, o2);
+          }
+          function U(e3, t2, n2, r2, o2) {
+            o2 || (d(null != t2, "missing value"), d("boolean" == typeof r2, "missing or invalid endian"), d(null != n2, "missing offset"), d(n2 + 3 < e3.length, "Trying to write beyond buffer length"), D(t2, 34028234663852886e22, -34028234663852886e22)), e3.length <= n2 || i.write(e3, t2, n2, r2, 23, 4);
+          }
+          function x(e3, t2, n2, r2, o2) {
+            o2 || (d(null != t2, "missing value"), d("boolean" == typeof r2, "missing or invalid endian"), d(null != n2, "missing offset"), d(n2 + 7 < e3.length, "Trying to write beyond buffer length"), D(t2, 17976931348623157e292, -17976931348623157e292)), e3.length <= n2 || i.write(e3, t2, n2, r2, 52, 8);
+          }
+          H.Buffer = f, H.SlowBuffer = f, H.INSPECT_MAX_BYTES = 50, f.poolSize = 8192, f._useTypedArrays = function() {
+            try {
+              var e3 = new ArrayBuffer(0), t2 = new Uint8Array(e3);
+              return t2.foo = function() {
+                return 42;
+              }, 42 === t2.foo() && "function" == typeof t2.subarray;
+            } catch (e4) {
+              return false;
+            }
+          }(), f.isEncoding = function(e3) {
+            switch (String(e3).toLowerCase()) {
+              case "hex":
+              case "utf8":
+              case "utf-8":
+              case "ascii":
+              case "binary":
+              case "base64":
+              case "raw":
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+                return true;
+              default:
+                return false;
+            }
+          }, f.isBuffer = function(e3) {
+            return !(null == e3 || !e3._isBuffer);
+          }, f.byteLength = function(e3, t2) {
+            var n2;
+            switch (e3 += "", t2 || "utf8") {
+              case "hex":
+                n2 = e3.length / 2;
+                break;
+              case "utf8":
+              case "utf-8":
+                n2 = T(e3).length;
+                break;
+              case "ascii":
+              case "binary":
+              case "raw":
+                n2 = e3.length;
+                break;
+              case "base64":
+                n2 = M(e3).length;
+                break;
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+                n2 = 2 * e3.length;
+                break;
+              default:
+                throw new Error("Unknown encoding");
+            }
+            return n2;
+          }, f.concat = function(e3, t2) {
+            if (d(C(e3), "Usage: Buffer.concat(list, [totalLength])\nlist should be an Array."), 0 === e3.length) return new f(0);
+            if (1 === e3.length) return e3[0];
+            if ("number" != typeof t2) for (o2 = t2 = 0; o2 < e3.length; o2++) t2 += e3[o2].length;
+            for (var n2 = new f(t2), r2 = 0, o2 = 0; o2 < e3.length; o2++) {
+              var i2 = e3[o2];
+              i2.copy(n2, r2), r2 += i2.length;
+            }
+            return n2;
+          }, f.prototype.write = function(e3, t2, n2, r2) {
+            isFinite(t2) ? isFinite(n2) || (r2 = n2, n2 = void 0) : (a2 = r2, r2 = t2, t2 = n2, n2 = a2), t2 = Number(t2) || 0;
+            var o2, i2, u2, s2, a2 = this.length - t2;
+            switch ((!n2 || a2 < (n2 = Number(n2))) && (n2 = a2), r2 = String(r2 || "utf8").toLowerCase()) {
+              case "hex":
+                o2 = function(e4, t3, n3, r3) {
+                  n3 = Number(n3) || 0;
+                  var o3 = e4.length - n3;
+                  (!r3 || o3 < (r3 = Number(r3))) && (r3 = o3), d((o3 = t3.length) % 2 == 0, "Invalid hex string"), o3 / 2 < r3 && (r3 = o3 / 2);
+                  for (var i3 = 0; i3 < r3; i3++) {
+                    var u3 = parseInt(t3.substr(2 * i3, 2), 16);
+                    d(!isNaN(u3), "Invalid hex string"), e4[n3 + i3] = u3;
+                  }
+                  return f._charsWritten = 2 * i3, i3;
+                }(this, e3, t2, n2);
+                break;
+              case "utf8":
+              case "utf-8":
+                i2 = this, u2 = t2, s2 = n2, o2 = f._charsWritten = c(T(e3), i2, u2, s2);
+                break;
+              case "ascii":
+              case "binary":
+                o2 = b(this, e3, t2, n2);
+                break;
+              case "base64":
+                i2 = this, u2 = t2, s2 = n2, o2 = f._charsWritten = c(M(e3), i2, u2, s2);
+                break;
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+                o2 = m(this, e3, t2, n2);
+                break;
+              default:
+                throw new Error("Unknown encoding");
+            }
+            return o2;
+          }, f.prototype.toString = function(e3, t2, n2) {
+            var r2, o2, i2, u2, s2 = this;
+            if (e3 = String(e3 || "utf8").toLowerCase(), t2 = Number(t2) || 0, (n2 = void 0 !== n2 ? Number(n2) : s2.length) === t2) return "";
+            switch (e3) {
+              case "hex":
+                r2 = function(e4, t3, n3) {
+                  var r3 = e4.length;
+                  (!t3 || t3 < 0) && (t3 = 0);
+                  (!n3 || n3 < 0 || r3 < n3) && (n3 = r3);
+                  for (var o3 = "", i3 = t3; i3 < n3; i3++) o3 += k(e4[i3]);
+                  return o3;
+                }(s2, t2, n2);
+                break;
+              case "utf8":
+              case "utf-8":
+                r2 = function(e4, t3, n3) {
+                  var r3 = "", o3 = "";
+                  n3 = Math.min(e4.length, n3);
+                  for (var i3 = t3; i3 < n3; i3++) e4[i3] <= 127 ? (r3 += N(o3) + String.fromCharCode(e4[i3]), o3 = "") : o3 += "%" + e4[i3].toString(16);
+                  return r3 + N(o3);
+                }(s2, t2, n2);
+                break;
+              case "ascii":
+              case "binary":
+                r2 = v(s2, t2, n2);
+                break;
+              case "base64":
+                o2 = s2, u2 = n2, r2 = 0 === (i2 = t2) && u2 === o2.length ? a.fromByteArray(o2) : a.fromByteArray(o2.slice(i2, u2));
+                break;
+              case "ucs2":
+              case "ucs-2":
+              case "utf16le":
+              case "utf-16le":
+                r2 = function(e4, t3, n3) {
+                  for (var r3 = e4.slice(t3, n3), o3 = "", i3 = 0; i3 < r3.length; i3 += 2) o3 += String.fromCharCode(r3[i3] + 256 * r3[i3 + 1]);
+                  return o3;
+                }(s2, t2, n2);
+                break;
+              default:
+                throw new Error("Unknown encoding");
+            }
+            return r2;
+          }, f.prototype.toJSON = function() {
+            return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
+          }, f.prototype.copy = function(e3, t2, n2, r2) {
+            if (t2 = t2 || 0, (r2 = r2 || 0 === r2 ? r2 : this.length) !== (n2 = n2 || 0) && 0 !== e3.length && 0 !== this.length) {
+              d(n2 <= r2, "sourceEnd < sourceStart"), d(0 <= t2 && t2 < e3.length, "targetStart out of bounds"), d(0 <= n2 && n2 < this.length, "sourceStart out of bounds"), d(0 <= r2 && r2 <= this.length, "sourceEnd out of bounds"), r2 > this.length && (r2 = this.length);
+              var o2 = (r2 = e3.length - t2 < r2 - n2 ? e3.length - t2 + n2 : r2) - n2;
+              if (o2 < 100 || !f._useTypedArrays) for (var i2 = 0; i2 < o2; i2++) e3[i2 + t2] = this[i2 + n2];
+              else e3._set(this.subarray(n2, n2 + o2), t2);
+            }
+          }, f.prototype.slice = function(e3, t2) {
+            var n2 = this.length;
+            if (e3 = S(e3, n2, 0), t2 = S(t2, n2, n2), f._useTypedArrays) return f._augment(this.subarray(e3, t2));
+            for (var r2 = t2 - e3, o2 = new f(r2, void 0, true), i2 = 0; i2 < r2; i2++) o2[i2] = this[i2 + e3];
+            return o2;
+          }, f.prototype.get = function(e3) {
+            return console.log(".get() is deprecated. Access using array indexes instead."), this.readUInt8(e3);
+          }, f.prototype.set = function(e3, t2) {
+            return console.log(".set() is deprecated. Access using array indexes instead."), this.writeUInt8(e3, t2);
+          }, f.prototype.readUInt8 = function(e3, t2) {
+            if (t2 || (d(null != e3, "missing offset"), d(e3 < this.length, "Trying to read beyond buffer length")), !(e3 >= this.length)) return this[e3];
+          }, f.prototype.readUInt16LE = function(e3, t2) {
+            return o(this, e3, true, t2);
+          }, f.prototype.readUInt16BE = function(e3, t2) {
+            return o(this, e3, false, t2);
+          }, f.prototype.readUInt32LE = function(e3, t2) {
+            return u(this, e3, true, t2);
+          }, f.prototype.readUInt32BE = function(e3, t2) {
+            return u(this, e3, false, t2);
+          }, f.prototype.readInt8 = function(e3, t2) {
+            if (t2 || (d(null != e3, "missing offset"), d(e3 < this.length, "Trying to read beyond buffer length")), !(e3 >= this.length)) return 128 & this[e3] ? -1 * (255 - this[e3] + 1) : this[e3];
+          }, f.prototype.readInt16LE = function(e3, t2) {
+            return _(this, e3, true, t2);
+          }, f.prototype.readInt16BE = function(e3, t2) {
+            return _(this, e3, false, t2);
+          }, f.prototype.readInt32LE = function(e3, t2) {
+            return E(this, e3, true, t2);
+          }, f.prototype.readInt32BE = function(e3, t2) {
+            return E(this, e3, false, t2);
+          }, f.prototype.readFloatLE = function(e3, t2) {
+            return I(this, e3, true, t2);
+          }, f.prototype.readFloatBE = function(e3, t2) {
+            return I(this, e3, false, t2);
+          }, f.prototype.readDoubleLE = function(e3, t2) {
+            return A(this, e3, true, t2);
+          }, f.prototype.readDoubleBE = function(e3, t2) {
+            return A(this, e3, false, t2);
+          }, f.prototype.writeUInt8 = function(e3, t2, n2) {
+            n2 || (d(null != e3, "missing value"), d(null != t2, "missing offset"), d(t2 < this.length, "trying to write beyond buffer length"), Y(e3, 255)), t2 >= this.length || (this[t2] = e3);
+          }, f.prototype.writeUInt16LE = function(e3, t2, n2) {
+            s(this, e3, t2, true, n2);
+          }, f.prototype.writeUInt16BE = function(e3, t2, n2) {
+            s(this, e3, t2, false, n2);
+          }, f.prototype.writeUInt32LE = function(e3, t2, n2) {
+            l(this, e3, t2, true, n2);
+          }, f.prototype.writeUInt32BE = function(e3, t2, n2) {
+            l(this, e3, t2, false, n2);
+          }, f.prototype.writeInt8 = function(e3, t2, n2) {
+            n2 || (d(null != e3, "missing value"), d(null != t2, "missing offset"), d(t2 < this.length, "Trying to write beyond buffer length"), F(e3, 127, -128)), t2 >= this.length || (0 <= e3 ? this.writeUInt8(e3, t2, n2) : this.writeUInt8(255 + e3 + 1, t2, n2));
+          }, f.prototype.writeInt16LE = function(e3, t2, n2) {
+            B(this, e3, t2, true, n2);
+          }, f.prototype.writeInt16BE = function(e3, t2, n2) {
+            B(this, e3, t2, false, n2);
+          }, f.prototype.writeInt32LE = function(e3, t2, n2) {
+            L(this, e3, t2, true, n2);
+          }, f.prototype.writeInt32BE = function(e3, t2, n2) {
+            L(this, e3, t2, false, n2);
+          }, f.prototype.writeFloatLE = function(e3, t2, n2) {
+            U(this, e3, t2, true, n2);
+          }, f.prototype.writeFloatBE = function(e3, t2, n2) {
+            U(this, e3, t2, false, n2);
+          }, f.prototype.writeDoubleLE = function(e3, t2, n2) {
+            x(this, e3, t2, true, n2);
+          }, f.prototype.writeDoubleBE = function(e3, t2, n2) {
+            x(this, e3, t2, false, n2);
+          }, f.prototype.fill = function(e3, t2, n2) {
+            if (t2 = t2 || 0, n2 = n2 || this.length, d("number" == typeof (e3 = "string" == typeof (e3 = e3 || 0) ? e3.charCodeAt(0) : e3) && !isNaN(e3), "value is not a number"), d(t2 <= n2, "end < start"), n2 !== t2 && 0 !== this.length) {
+              d(0 <= t2 && t2 < this.length, "start out of bounds"), d(0 <= n2 && n2 <= this.length, "end out of bounds");
+              for (var r2 = t2; r2 < n2; r2++) this[r2] = e3;
+            }
+          }, f.prototype.inspect = function() {
+            for (var e3 = [], t2 = this.length, n2 = 0; n2 < t2; n2++) if (e3[n2] = k(this[n2]), n2 === H.INSPECT_MAX_BYTES) {
+              e3[n2 + 1] = "...";
+              break;
+            }
+            return "<Buffer " + e3.join(" ") + ">";
+          }, f.prototype.toArrayBuffer = function() {
+            if ("undefined" == typeof Uint8Array) throw new Error("Buffer.toArrayBuffer not supported in this browser");
+            if (f._useTypedArrays) return new f(this).buffer;
+            for (var e3 = new Uint8Array(this.length), t2 = 0, n2 = e3.length; t2 < n2; t2 += 1) e3[t2] = this[t2];
+            return e3.buffer;
+          };
+          var t = f.prototype;
+          function S(e3, t2, n2) {
+            return "number" != typeof e3 ? n2 : t2 <= (e3 = ~~e3) ? t2 : 0 <= e3 || 0 <= (e3 += t2) ? e3 : 0;
+          }
+          function j(e3) {
+            return (e3 = ~~Math.ceil(+e3)) < 0 ? 0 : e3;
+          }
+          function C(e3) {
+            return (Array.isArray || function(e4) {
+              return "[object Array]" === Object.prototype.toString.call(e4);
+            })(e3);
+          }
+          function k(e3) {
+            return e3 < 16 ? "0" + e3.toString(16) : e3.toString(16);
+          }
+          function T(e3) {
+            for (var t2 = [], n2 = 0; n2 < e3.length; n2++) {
+              var r2 = e3.charCodeAt(n2);
+              if (r2 <= 127) t2.push(e3.charCodeAt(n2));
+              else for (var o2 = n2, i2 = (55296 <= r2 && r2 <= 57343 && n2++, encodeURIComponent(e3.slice(o2, n2 + 1)).substr(1).split("%")), u2 = 0; u2 < i2.length; u2++) t2.push(parseInt(i2[u2], 16));
+            }
+            return t2;
+          }
+          function M(e3) {
+            return a.toByteArray(e3);
+          }
+          function c(e3, t2, n2, r2) {
+            for (var o2 = 0; o2 < r2 && !(o2 + n2 >= t2.length || o2 >= e3.length); o2++) t2[o2 + n2] = e3[o2];
+            return o2;
+          }
+          function N(e3) {
+            try {
+              return decodeURIComponent(e3);
+            } catch (e4) {
+              return String.fromCharCode(65533);
+            }
+          }
+          function Y(e3, t2) {
+            d("number" == typeof e3, "cannot write a non-number as a number"), d(0 <= e3, "specified a negative value for writing an unsigned value"), d(e3 <= t2, "value is larger than maximum value for type"), d(Math.floor(e3) === e3, "value has a fractional component");
+          }
+          function F(e3, t2, n2) {
+            d("number" == typeof e3, "cannot write a non-number as a number"), d(e3 <= t2, "value larger than maximum allowed value"), d(n2 <= e3, "value smaller than minimum allowed value"), d(Math.floor(e3) === e3, "value has a fractional component");
+          }
+          function D(e3, t2, n2) {
+            d("number" == typeof e3, "cannot write a non-number as a number"), d(e3 <= t2, "value larger than maximum allowed value"), d(n2 <= e3, "value smaller than minimum allowed value");
+          }
+          function d(e3, t2) {
+            if (!e3) throw new Error(t2 || "Failed assertion");
+          }
+          f._augment = function(e3) {
+            return e3._isBuffer = true, e3._get = e3.get, e3._set = e3.set, e3.get = t.get, e3.set = t.set, e3.write = t.write, e3.toString = t.toString, e3.toLocaleString = t.toString, e3.toJSON = t.toJSON, e3.copy = t.copy, e3.slice = t.slice, e3.readUInt8 = t.readUInt8, e3.readUInt16LE = t.readUInt16LE, e3.readUInt16BE = t.readUInt16BE, e3.readUInt32LE = t.readUInt32LE, e3.readUInt32BE = t.readUInt32BE, e3.readInt8 = t.readInt8, e3.readInt16LE = t.readInt16LE, e3.readInt16BE = t.readInt16BE, e3.readInt32LE = t.readInt32LE, e3.readInt32BE = t.readInt32BE, e3.readFloatLE = t.readFloatLE, e3.readFloatBE = t.readFloatBE, e3.readDoubleLE = t.readDoubleLE, e3.readDoubleBE = t.readDoubleBE, e3.writeUInt8 = t.writeUInt8, e3.writeUInt16LE = t.writeUInt16LE, e3.writeUInt16BE = t.writeUInt16BE, e3.writeUInt32LE = t.writeUInt32LE, e3.writeUInt32BE = t.writeUInt32BE, e3.writeInt8 = t.writeInt8, e3.writeInt16LE = t.writeInt16LE, e3.writeInt16BE = t.writeInt16BE, e3.writeInt32LE = t.writeInt32LE, e3.writeInt32BE = t.writeInt32BE, e3.writeFloatLE = t.writeFloatLE, e3.writeFloatBE = t.writeFloatBE, e3.writeDoubleLE = t.writeDoubleLE, e3.writeDoubleBE = t.writeDoubleBE, e3.fill = t.fill, e3.inspect = t.inspect, e3.toArrayBuffer = t.toArrayBuffer, e3;
+          };
+        }).call(this, O("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, O("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/buffer/index.js", "/node_modules/gulp-browserify/node_modules/buffer");
+      }, { "base64-js": 2, buffer: 3, ieee754: 10, lYpoI2: 11 }], 4: [function(c, d, e) {
+        !(function(e2, t, a, n, r, o, i, u, s) {
+          var a = c("buffer").Buffer, f = 4, l = new a(f);
+          l.fill(0);
+          d.exports = { hash: function(e3, t2, n2, r2) {
+            for (var o2 = t2(function(e4, t3) {
+              e4.length % f != 0 && (n3 = e4.length + (f - e4.length % f), e4 = a.concat([e4, l], n3));
+              for (var n3, r3 = [], o3 = t3 ? e4.readInt32BE : e4.readInt32LE, i3 = 0; i3 < e4.length; i3 += f) r3.push(o3.call(e4, i3));
+              return r3;
+            }(e3 = a.isBuffer(e3) ? e3 : new a(e3), r2), 8 * e3.length), t2 = r2, i2 = new a(n2), u2 = t2 ? i2.writeInt32BE : i2.writeInt32LE, s2 = 0; s2 < o2.length; s2++) u2.call(i2, o2[s2], 4 * s2, true);
+            return i2;
+          } };
+        }).call(this, c("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, c("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/helpers.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+      }, { buffer: 3, lYpoI2: 11 }], 5: [function(v, e, _) {
+        !(function(l, c, u, d, h, p, g, y, w) {
+          var u = v("buffer").Buffer, e2 = v("./sha"), t = v("./sha256"), n = v("./rng"), b = { sha1: e2, sha256: t, md5: v("./md5") }, s = 64, a = new u(s);
+          function r(e3, n2) {
+            var r2 = b[e3 = e3 || "sha1"], o2 = [];
+            return r2 || i("algorithm:", e3, "is not yet supported"), { update: function(e4) {
+              return u.isBuffer(e4) || (e4 = new u(e4)), o2.push(e4), e4.length, this;
+            }, digest: function(e4) {
+              var t2 = u.concat(o2), t2 = n2 ? function(e5, t3, n3) {
+                u.isBuffer(t3) || (t3 = new u(t3)), u.isBuffer(n3) || (n3 = new u(n3)), t3.length > s ? t3 = e5(t3) : t3.length < s && (t3 = u.concat([t3, a], s));
+                for (var r3 = new u(s), o3 = new u(s), i2 = 0; i2 < s; i2++) r3[i2] = 54 ^ t3[i2], o3[i2] = 92 ^ t3[i2];
+                return n3 = e5(u.concat([r3, n3])), e5(u.concat([o3, n3]));
+              }(r2, n2, t2) : r2(t2);
+              return o2 = null, e4 ? t2.toString(e4) : t2;
+            } };
+          }
+          function i() {
+            var e3 = [].slice.call(arguments).join(" ");
+            throw new Error([e3, "we accept pull requests", "http://github.com/dominictarr/crypto-browserify"].join("\n"));
+          }
+          a.fill(0), _.createHash = function(e3) {
+            return r(e3);
+          }, _.createHmac = r, _.randomBytes = function(e3, t2) {
+            if (!t2 || !t2.call) return new u(n(e3));
+            try {
+              t2.call(this, void 0, new u(n(e3)));
+            } catch (e4) {
+              t2(e4);
+            }
+          };
+          var o, f = ["createCredentials", "createCipher", "createCipheriv", "createDecipher", "createDecipheriv", "createSign", "createVerify", "createDiffieHellman", "pbkdf2"], m = function(e3) {
+            _[e3] = function() {
+              i("sorry,", e3, "is not implemented yet");
+            };
+          };
+          for (o in f) m(f[o]);
+        }).call(this, v("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, v("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/index.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+      }, { "./md5": 6, "./rng": 7, "./sha": 8, "./sha256": 9, buffer: 3, lYpoI2: 11 }], 6: [function(w, b, e) {
+        !(function(e2, r, o, i, u, a, f, l, y) {
+          var t = w("./helpers");
+          function n(e3, t2) {
+            e3[t2 >> 5] |= 128 << t2 % 32, e3[14 + (t2 + 64 >>> 9 << 4)] = t2;
+            for (var n2 = 1732584193, r2 = -271733879, o2 = -1732584194, i2 = 271733878, u2 = 0; u2 < e3.length; u2 += 16) {
+              var s2 = n2, a2 = r2, f2 = o2, l2 = i2, n2 = c(n2, r2, o2, i2, e3[u2 + 0], 7, -680876936), i2 = c(i2, n2, r2, o2, e3[u2 + 1], 12, -389564586), o2 = c(o2, i2, n2, r2, e3[u2 + 2], 17, 606105819), r2 = c(r2, o2, i2, n2, e3[u2 + 3], 22, -1044525330);
+              n2 = c(n2, r2, o2, i2, e3[u2 + 4], 7, -176418897), i2 = c(i2, n2, r2, o2, e3[u2 + 5], 12, 1200080426), o2 = c(o2, i2, n2, r2, e3[u2 + 6], 17, -1473231341), r2 = c(r2, o2, i2, n2, e3[u2 + 7], 22, -45705983), n2 = c(n2, r2, o2, i2, e3[u2 + 8], 7, 1770035416), i2 = c(i2, n2, r2, o2, e3[u2 + 9], 12, -1958414417), o2 = c(o2, i2, n2, r2, e3[u2 + 10], 17, -42063), r2 = c(r2, o2, i2, n2, e3[u2 + 11], 22, -1990404162), n2 = c(n2, r2, o2, i2, e3[u2 + 12], 7, 1804603682), i2 = c(i2, n2, r2, o2, e3[u2 + 13], 12, -40341101), o2 = c(o2, i2, n2, r2, e3[u2 + 14], 17, -1502002290), n2 = d(n2, r2 = c(r2, o2, i2, n2, e3[u2 + 15], 22, 1236535329), o2, i2, e3[u2 + 1], 5, -165796510), i2 = d(i2, n2, r2, o2, e3[u2 + 6], 9, -1069501632), o2 = d(o2, i2, n2, r2, e3[u2 + 11], 14, 643717713), r2 = d(r2, o2, i2, n2, e3[u2 + 0], 20, -373897302), n2 = d(n2, r2, o2, i2, e3[u2 + 5], 5, -701558691), i2 = d(i2, n2, r2, o2, e3[u2 + 10], 9, 38016083), o2 = d(o2, i2, n2, r2, e3[u2 + 15], 14, -660478335), r2 = d(r2, o2, i2, n2, e3[u2 + 4], 20, -405537848), n2 = d(n2, r2, o2, i2, e3[u2 + 9], 5, 568446438), i2 = d(i2, n2, r2, o2, e3[u2 + 14], 9, -1019803690), o2 = d(o2, i2, n2, r2, e3[u2 + 3], 14, -187363961), r2 = d(r2, o2, i2, n2, e3[u2 + 8], 20, 1163531501), n2 = d(n2, r2, o2, i2, e3[u2 + 13], 5, -1444681467), i2 = d(i2, n2, r2, o2, e3[u2 + 2], 9, -51403784), o2 = d(o2, i2, n2, r2, e3[u2 + 7], 14, 1735328473), n2 = h(n2, r2 = d(r2, o2, i2, n2, e3[u2 + 12], 20, -1926607734), o2, i2, e3[u2 + 5], 4, -378558), i2 = h(i2, n2, r2, o2, e3[u2 + 8], 11, -2022574463), o2 = h(o2, i2, n2, r2, e3[u2 + 11], 16, 1839030562), r2 = h(r2, o2, i2, n2, e3[u2 + 14], 23, -35309556), n2 = h(n2, r2, o2, i2, e3[u2 + 1], 4, -1530992060), i2 = h(i2, n2, r2, o2, e3[u2 + 4], 11, 1272893353), o2 = h(o2, i2, n2, r2, e3[u2 + 7], 16, -155497632), r2 = h(r2, o2, i2, n2, e3[u2 + 10], 23, -1094730640), n2 = h(n2, r2, o2, i2, e3[u2 + 13], 4, 681279174), i2 = h(i2, n2, r2, o2, e3[u2 + 0], 11, -358537222), o2 = h(o2, i2, n2, r2, e3[u2 + 3], 16, -722521979), r2 = h(r2, o2, i2, n2, e3[u2 + 6], 23, 76029189), n2 = h(n2, r2, o2, i2, e3[u2 + 9], 4, -640364487), i2 = h(i2, n2, r2, o2, e3[u2 + 12], 11, -421815835), o2 = h(o2, i2, n2, r2, e3[u2 + 15], 16, 530742520), n2 = p(n2, r2 = h(r2, o2, i2, n2, e3[u2 + 2], 23, -995338651), o2, i2, e3[u2 + 0], 6, -198630844), i2 = p(i2, n2, r2, o2, e3[u2 + 7], 10, 1126891415), o2 = p(o2, i2, n2, r2, e3[u2 + 14], 15, -1416354905), r2 = p(r2, o2, i2, n2, e3[u2 + 5], 21, -57434055), n2 = p(n2, r2, o2, i2, e3[u2 + 12], 6, 1700485571), i2 = p(i2, n2, r2, o2, e3[u2 + 3], 10, -1894986606), o2 = p(o2, i2, n2, r2, e3[u2 + 10], 15, -1051523), r2 = p(r2, o2, i2, n2, e3[u2 + 1], 21, -2054922799), n2 = p(n2, r2, o2, i2, e3[u2 + 8], 6, 1873313359), i2 = p(i2, n2, r2, o2, e3[u2 + 15], 10, -30611744), o2 = p(o2, i2, n2, r2, e3[u2 + 6], 15, -1560198380), r2 = p(r2, o2, i2, n2, e3[u2 + 13], 21, 1309151649), n2 = p(n2, r2, o2, i2, e3[u2 + 4], 6, -145523070), i2 = p(i2, n2, r2, o2, e3[u2 + 11], 10, -1120210379), o2 = p(o2, i2, n2, r2, e3[u2 + 2], 15, 718787259), r2 = p(r2, o2, i2, n2, e3[u2 + 9], 21, -343485551), n2 = g(n2, s2), r2 = g(r2, a2), o2 = g(o2, f2), i2 = g(i2, l2);
+            }
+            return Array(n2, r2, o2, i2);
+          }
+          function s(e3, t2, n2, r2, o2, i2) {
+            return g((t2 = g(g(t2, e3), g(r2, i2))) << o2 | t2 >>> 32 - o2, n2);
+          }
+          function c(e3, t2, n2, r2, o2, i2, u2) {
+            return s(t2 & n2 | ~t2 & r2, e3, t2, o2, i2, u2);
+          }
+          function d(e3, t2, n2, r2, o2, i2, u2) {
+            return s(t2 & r2 | n2 & ~r2, e3, t2, o2, i2, u2);
+          }
+          function h(e3, t2, n2, r2, o2, i2, u2) {
+            return s(t2 ^ n2 ^ r2, e3, t2, o2, i2, u2);
+          }
+          function p(e3, t2, n2, r2, o2, i2, u2) {
+            return s(n2 ^ (t2 | ~r2), e3, t2, o2, i2, u2);
+          }
+          function g(e3, t2) {
+            var n2 = (65535 & e3) + (65535 & t2);
+            return (e3 >> 16) + (t2 >> 16) + (n2 >> 16) << 16 | 65535 & n2;
+          }
+          b.exports = function(e3) {
+            return t.hash(e3, n, 16);
+          };
+        }).call(this, w("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, w("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/md5.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+      }, { "./helpers": 4, buffer: 3, lYpoI2: 11 }], 7: [function(e, l, t) {
+        !(function(e2, t2, n, r, o, i, u, s, f) {
+          l.exports = function(e3) {
+            for (var t3, n2 = new Array(e3), r2 = 0; r2 < e3; r2++) 0 == (3 & r2) && (t3 = 4294967296 * Math.random()), n2[r2] = t3 >>> ((3 & r2) << 3) & 255;
+            return n2;
+          };
+        }).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/rng.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+      }, { buffer: 3, lYpoI2: 11 }], 8: [function(c, d, e) {
+        !(function(e2, t, n, r, o, s, a, f, l) {
+          var i = c("./helpers");
+          function u(l2, c2) {
+            l2[c2 >> 5] |= 128 << 24 - c2 % 32, l2[15 + (c2 + 64 >> 9 << 4)] = c2;
+            for (var e3, t2, n2, r2 = Array(80), o2 = 1732584193, i2 = -271733879, u2 = -1732584194, s2 = 271733878, d2 = -1009589776, h = 0; h < l2.length; h += 16) {
+              for (var p = o2, g = i2, y = u2, w = s2, b = d2, a2 = 0; a2 < 80; a2++) {
+                r2[a2] = a2 < 16 ? l2[h + a2] : v(r2[a2 - 3] ^ r2[a2 - 8] ^ r2[a2 - 14] ^ r2[a2 - 16], 1);
+                var f2 = m(m(v(o2, 5), (f2 = i2, t2 = u2, n2 = s2, (e3 = a2) < 20 ? f2 & t2 | ~f2 & n2 : !(e3 < 40) && e3 < 60 ? f2 & t2 | f2 & n2 | t2 & n2 : f2 ^ t2 ^ n2)), m(m(d2, r2[a2]), (e3 = a2) < 20 ? 1518500249 : e3 < 40 ? 1859775393 : e3 < 60 ? -1894007588 : -899497514)), d2 = s2, s2 = u2, u2 = v(i2, 30), i2 = o2, o2 = f2;
+              }
+              o2 = m(o2, p), i2 = m(i2, g), u2 = m(u2, y), s2 = m(s2, w), d2 = m(d2, b);
+            }
+            return Array(o2, i2, u2, s2, d2);
+          }
+          function m(e3, t2) {
+            var n2 = (65535 & e3) + (65535 & t2);
+            return (e3 >> 16) + (t2 >> 16) + (n2 >> 16) << 16 | 65535 & n2;
+          }
+          function v(e3, t2) {
+            return e3 << t2 | e3 >>> 32 - t2;
+          }
+          d.exports = function(e3) {
+            return i.hash(e3, u, 20, true);
+          };
+        }).call(this, c("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, c("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/sha.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+      }, { "./helpers": 4, buffer: 3, lYpoI2: 11 }], 9: [function(c, d, e) {
+        !(function(e2, t, n, r, u, s, a, f, l) {
+          function b(e3, t2) {
+            var n2 = (65535 & e3) + (65535 & t2);
+            return (e3 >> 16) + (t2 >> 16) + (n2 >> 16) << 16 | 65535 & n2;
+          }
+          function o(e3, l2) {
+            var c2, d2 = new Array(1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298), t2 = new Array(1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225), n2 = new Array(64);
+            e3[l2 >> 5] |= 128 << 24 - l2 % 32, e3[15 + (l2 + 64 >> 9 << 4)] = l2;
+            for (var r2, o2, h = 0; h < e3.length; h += 16) {
+              for (var i2 = t2[0], u2 = t2[1], s2 = t2[2], p = t2[3], a2 = t2[4], g = t2[5], y = t2[6], w = t2[7], f2 = 0; f2 < 64; f2++) n2[f2] = f2 < 16 ? e3[f2 + h] : b(b(b((o2 = n2[f2 - 2], m(o2, 17) ^ m(o2, 19) ^ v(o2, 10)), n2[f2 - 7]), (o2 = n2[f2 - 15], m(o2, 7) ^ m(o2, 18) ^ v(o2, 3))), n2[f2 - 16]), c2 = b(b(b(b(w, m(o2 = a2, 6) ^ m(o2, 11) ^ m(o2, 25)), a2 & g ^ ~a2 & y), d2[f2]), n2[f2]), r2 = b(m(r2 = i2, 2) ^ m(r2, 13) ^ m(r2, 22), i2 & u2 ^ i2 & s2 ^ u2 & s2), w = y, y = g, g = a2, a2 = b(p, c2), p = s2, s2 = u2, u2 = i2, i2 = b(c2, r2);
+              t2[0] = b(i2, t2[0]), t2[1] = b(u2, t2[1]), t2[2] = b(s2, t2[2]), t2[3] = b(p, t2[3]), t2[4] = b(a2, t2[4]), t2[5] = b(g, t2[5]), t2[6] = b(y, t2[6]), t2[7] = b(w, t2[7]);
+            }
+            return t2;
+          }
+          var i = c("./helpers"), m = function(e3, t2) {
+            return e3 >>> t2 | e3 << 32 - t2;
+          }, v = function(e3, t2) {
+            return e3 >>> t2;
+          };
+          d.exports = function(e3) {
+            return i.hash(e3, o, 32, true);
+          };
+        }).call(this, c("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, c("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/sha256.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+      }, { "./helpers": 4, buffer: 3, lYpoI2: 11 }], 10: [function(e, t, f) {
+        !(function(e2, t2, n, r, o, i, u, s, a) {
+          f.read = function(e3, t3, n2, r2, o2) {
+            var i2, u2, l = 8 * o2 - r2 - 1, c = (1 << l) - 1, d = c >> 1, s2 = -7, a2 = n2 ? o2 - 1 : 0, f2 = n2 ? -1 : 1, o2 = e3[t3 + a2];
+            for (a2 += f2, i2 = o2 & (1 << -s2) - 1, o2 >>= -s2, s2 += l; 0 < s2; i2 = 256 * i2 + e3[t3 + a2], a2 += f2, s2 -= 8) ;
+            for (u2 = i2 & (1 << -s2) - 1, i2 >>= -s2, s2 += r2; 0 < s2; u2 = 256 * u2 + e3[t3 + a2], a2 += f2, s2 -= 8) ;
+            if (0 === i2) i2 = 1 - d;
+            else {
+              if (i2 === c) return u2 ? NaN : 1 / 0 * (o2 ? -1 : 1);
+              u2 += Math.pow(2, r2), i2 -= d;
+            }
+            return (o2 ? -1 : 1) * u2 * Math.pow(2, i2 - r2);
+          }, f.write = function(e3, t3, l, n2, r2, c) {
+            var o2, i2, u2 = 8 * c - r2 - 1, s2 = (1 << u2) - 1, a2 = s2 >> 1, d = 23 === r2 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, f2 = n2 ? 0 : c - 1, h = n2 ? 1 : -1, c = t3 < 0 || 0 === t3 && 1 / t3 < 0 ? 1 : 0;
+            for (t3 = Math.abs(t3), isNaN(t3) || t3 === 1 / 0 ? (i2 = isNaN(t3) ? 1 : 0, o2 = s2) : (o2 = Math.floor(Math.log(t3) / Math.LN2), t3 * (n2 = Math.pow(2, -o2)) < 1 && (o2--, n2 *= 2), 2 <= (t3 += 1 <= o2 + a2 ? d / n2 : d * Math.pow(2, 1 - a2)) * n2 && (o2++, n2 /= 2), s2 <= o2 + a2 ? (i2 = 0, o2 = s2) : 1 <= o2 + a2 ? (i2 = (t3 * n2 - 1) * Math.pow(2, r2), o2 += a2) : (i2 = t3 * Math.pow(2, a2 - 1) * Math.pow(2, r2), o2 = 0)); 8 <= r2; e3[l + f2] = 255 & i2, f2 += h, i2 /= 256, r2 -= 8) ;
+            for (o2 = o2 << r2 | i2, u2 += r2; 0 < u2; e3[l + f2] = 255 & o2, f2 += h, o2 /= 256, u2 -= 8) ;
+            e3[l + f2 - h] |= 128 * c;
+          };
+        }).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/ieee754/index.js", "/node_modules/gulp-browserify/node_modules/ieee754");
+      }, { buffer: 3, lYpoI2: 11 }], 11: [function(e, h, t) {
+        !(function(e2, t2, n, r, o, f, l, c, d) {
+          var i, u, s;
+          function a() {
+          }
+          (e2 = h.exports = {}).nextTick = (u = "undefined" != typeof window && window.setImmediate, s = "undefined" != typeof window && window.postMessage && window.addEventListener, u ? function(e3) {
+            return window.setImmediate(e3);
+          } : s ? (i = [], window.addEventListener("message", function(e3) {
+            var t3 = e3.source;
+            t3 !== window && null !== t3 || "process-tick" !== e3.data || (e3.stopPropagation(), 0 < i.length && i.shift()());
+          }, true), function(e3) {
+            i.push(e3), window.postMessage("process-tick", "*");
+          }) : function(e3) {
+            setTimeout(e3, 0);
+          }), e2.title = "browser", e2.browser = true, e2.env = {}, e2.argv = [], e2.on = a, e2.addListener = a, e2.once = a, e2.off = a, e2.removeListener = a, e2.removeAllListeners = a, e2.emit = a, e2.binding = function(e3) {
+            throw new Error("process.binding is not supported");
+          }, e2.cwd = function() {
+            return "/";
+          }, e2.chdir = function(e3) {
+            throw new Error("process.chdir is not supported");
+          };
+        }).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/process/browser.js", "/node_modules/gulp-browserify/node_modules/process");
+      }, { buffer: 3, lYpoI2: 11 }] }, {}, [1])(1);
+    });
+  })(object_hash);
+  return object_hash.exports;
+}
+var object_hashExports = requireObject_hash();
+const hash = /* @__PURE__ */ getDefaultExportFromCjs(object_hashExports);
+function isActivitySource(obj) {
+  return isSingleDocSource(obj) || isSelectSource(obj) || isSequenceSource(obj);
+}
+function isActivityStateNoSource(obj) {
+  return isSingleDocStateNoSource(obj) || isSelectStateNoSource(obj) || isSequenceStateNoSource(obj);
+}
+function isExportedActivityState(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && isActivityStateNoSource(typedObj.activityState) && Array.isArray(typedObj.doenetStates) && Array.isArray(typedObj.itemAttemptNumbers) && typedObj.itemAttemptNumbers.every(
+      (x) => Number.isInteger(x) && x > 0
+    ) && typeof typedObj.sourceHash === "string"
+  );
+}
+function initializeActivityState({
+  source,
+  variant,
+  parentId,
+  numActivityVariants,
+  restrictToVariantSlice
+}) {
+  switch (source.type) {
+    case "singleDoc": {
+      return initializeSingleDocState({
+        source,
+        variant,
+        parentId,
+        restrictToVariantSlice
+      });
+    }
+    case "select": {
+      return initializeSelectState({
+        source,
+        variant,
+        parentId,
+        numActivityVariants,
+        restrictToVariantSlice
+      });
+    }
+    case "sequence": {
+      return initializeSequenceState({
+        source,
+        variant,
+        parentId,
+        numActivityVariants,
+        restrictToVariantSlice
+      });
+    }
+  }
+  throw Error("Invalid activity type");
+}
+function initializeActivityAndDoenetState({
+  source,
+  variant,
+  parentId,
+  numActivityVariants,
+  restrictToVariantSlice
+}) {
+  const activityState = initializeActivityState({
+    source,
+    variant,
+    parentId,
+    numActivityVariants,
+    restrictToVariantSlice
+  });
+  const numItems = getNumItems(source);
+  const itemAttemptNumbers = Array(numItems).fill(1);
+  return { activityState, doenetStates: [], itemAttemptNumbers };
+}
+function generateNewActivityAttempt({
+  state,
+  numActivityVariants,
+  initialQuestionCounter,
+  parentAttempt
+}) {
+  switch (state.type) {
+    case "singleDoc": {
+      return generateNewSingleDocAttempt({
+        state,
+        numActivityVariants,
+        initialQuestionCounter,
+        parentAttempt
+      });
+    }
+    case "select": {
+      return generateNewSelectAttempt({
+        state,
+        numActivityVariants,
+        initialQuestionCounter,
+        parentAttempt
+      });
+    }
+    case "sequence": {
+      return generateNewSequenceAttempt({
+        state,
+        numActivityVariants,
+        initialQuestionCounter,
+        parentAttempt
+      });
+    }
+  }
+  throw Error("Invalid activity type");
+}
+function generateNewSingleDocSubAttempt({
+  singleDocId,
+  state,
+  numActivityVariants,
+  initialQuestionCounter
+}) {
+  if (singleDocId === state.id) {
+    throw Error(
+      "Should not call generateSingleDocSubActivityAttempt on entire activity"
+    );
+  }
+  const allStates = gatherStates(state);
+  const singleDocActivityState = allStates[singleDocId];
+  if (singleDocActivityState.type !== "singleDoc") {
+    throw Error(
+      "generateNewSingleDocSubAttempt implemented only for single documents"
+    );
+  }
+  if (singleDocActivityState.parentId === null) {
+    throw Error("Lower lever should have parent");
+  }
+  const parentState = allStates[singleDocActivityState.parentId];
+  if (parentState.type === "select" && parentState.allChildren.every((child) => child.type === "singleDoc")) {
+    const grandParentAttempt = parentState.parentId ? allStates[parentState.parentId].attemptNumber : 1;
+    let newParentState;
+    if (parentState.source.numToSelect > 1) {
+      ({ state: newParentState } = generateNewSingleDocAttemptForMultiSelect({
+        state: parentState,
+        numActivityVariants,
+        initialQuestionCounter,
+        parentAttempt: grandParentAttempt,
+        childId: singleDocId
+      }));
+    } else {
+      ({ state: newParentState } = generateNewActivityAttempt({
+        state: parentState,
+        numActivityVariants,
+        initialQuestionCounter,
+        parentAttempt: grandParentAttempt
+      }));
+    }
+    allStates[parentState.id] = newParentState;
+    return propagateStateChangeToRoot({
+      allStates,
+      id: parentState.id
+    });
+  } else {
+    const { state: newSubActivityState } = generateNewActivityAttempt({
+      state: allStates[singleDocId],
+      numActivityVariants,
+      initialQuestionCounter,
+      parentAttempt: parentState.attemptNumber
+    });
+    allStates[singleDocId] = newSubActivityState;
+    return propagateStateChangeToRoot({
+      allStates,
+      id: singleDocId
+    });
+  }
+}
+function extractActivityItemCredit(activityState, nPrevInShuffleOrder = 0) {
+  switch (activityState.type) {
+    case "singleDoc": {
+      return extractSingleDocItemCredit(
+        activityState,
+        nPrevInShuffleOrder
+      );
+    }
+    case "select": {
+      return extractSelectItemCredit(activityState, nPrevInShuffleOrder);
+    }
+    case "sequence": {
+      return extractSequenceItemCredit(
+        activityState,
+        nPrevInShuffleOrder
+      );
+    }
+  }
+}
+function pruneActivityStateForSave(activityState) {
+  switch (activityState.type) {
+    case "singleDoc": {
+      return pruneSingleDocStateForSave(activityState);
+    }
+    case "select": {
+      return pruneSelectStateForSave(activityState);
+    }
+    case "sequence": {
+      return pruneSequenceStateForSave(activityState);
+    }
+  }
+}
+function addSourceToActivityState(activityState, source) {
+  switch (activityState.type) {
+    case "singleDoc": {
+      if (isSingleDocSource(source)) {
+        return addSourceToSingleDocState(activityState, source);
+      } else {
+        throw Error("Source didn't match state");
+      }
+    }
+    case "select": {
+      if (isSelectSource(source)) {
+        return addSourceToSelectState(activityState, source);
+      } else {
+        throw Error("Source didn't make state");
+      }
+    }
+    case "sequence": {
+      if (isSequenceSource(source)) {
+        return addSourceToSequenceState(activityState, source);
+      } else {
+        throw Error("Source didn't match state");
+      }
+    }
+  }
+}
+function extractSourceId(compositeId) {
+  return compositeId.split("|")[0];
+}
+function getItemSequence(state) {
+  if (state.type === "singleDoc") {
+    return [state.id];
+  } else {
+    const numAttempts = state.attemptNumber;
+    if (numAttempts === 0) {
+      if (state.allChildren.length === 0) {
+        return [];
+      } else {
+        const prelimResult = state.allChildren.flatMap(
+          (a) => getItemSequence(a)
+        );
+        if (state.type === "sequence") {
+          return prelimResult;
+        } else {
+          return prelimResult.slice(0, state.source.numToSelect);
+        }
+      }
+    }
+    if (state.type === "sequence") {
+      return state.orderedChildren.flatMap((a) => getItemSequence(a));
+    } else {
+      return state.selectedChildren.flatMap((a) => getItemSequence(a));
+    }
+  }
+}
+function calcNumVariants(source, numActivityVariants) {
+  switch (source.type) {
+    case "singleDoc": {
+      return numActivityVariants[source.id];
+    }
+    case "select": {
+      return calcNumVariantsSelect(source, numActivityVariants);
+    }
+    case "sequence": {
+      return calcNumVariantsSequence(source, numActivityVariants);
+    }
+  }
+}
+function calcNumVariantsFromState(state, numActivityVariants) {
+  let numVariants = calcNumVariants(state.source, numActivityVariants);
+  if (state.restrictToVariantSlice) {
+    numVariants = Math.ceil(
+      (numVariants - state.restrictToVariantSlice.idx + 1) / state.restrictToVariantSlice.numSlices
+    );
+  }
+  return numVariants;
+}
+function getNumItems(source) {
+  switch (source.type) {
+    case "singleDoc": {
+      return 1;
+    }
+    case "select": {
+      return getNumItemsInSelect(source);
+    }
+    case "sequence": {
+      return getNumItemsInSequence(source);
+    }
+  }
+  throw Error("Invalid activity type");
+}
+function validateIds(source) {
+  if (source.id.includes("|")) {
+    throw Error(`Id "${source.id}" contains a "|".`);
+  }
+  const idsFound = [source.id];
+  if (source.type !== "singleDoc") {
+    for (const item of source.items) {
+      idsFound.push(...validateIds(item));
+    }
+  }
+  if ([...new Set(idsFound)].length !== idsFound.length) {
+    throw Error("Duplicate ids encountered in source");
+  }
+  return idsFound;
+}
+function gatherDocumentStructure(source) {
+  if (source.type === "singleDoc") {
+    return {
+      numActivityVariants: { [source.id]: source.numVariants ?? 1 }
+    };
+  } else {
+    const numActivityVariants = {};
+    for (const item of source.items) {
+      const res = gatherDocumentStructure(item);
+      Object.assign(numActivityVariants, res.numActivityVariants);
+    }
+    return { numActivityVariants };
+  }
+}
+function validateStateAndSource(state, source) {
+  if (!isExportedActivityState(state) || !isActivitySource(source)) {
+    return false;
+  }
+  const sourceHash = createSourceHash(source);
+  return state.sourceHash === sourceHash;
+}
+function gatherStates(state) {
+  const allStates = {
+    [state.id]: state
+  };
+  if (state.type !== "singleDoc") {
+    for (const child of state.allChildren) {
+      Object.assign(allStates, gatherStates(child));
+    }
+  }
+  return allStates;
+}
+function propagateStateChangeToRoot({
+  allStates,
+  id
+}) {
+  const activityState = allStates[id];
+  if (activityState.parentId === null) {
+    return activityState;
+  }
+  const newParentState = allStates[activityState.parentId] = {
+    ...allStates[activityState.parentId]
+  };
+  if (newParentState.type === "singleDoc") {
+    throw Error("Single doc activity cannot be a parent");
+  }
+  const childIdx = newParentState.allChildren.map((child) => child.id).indexOf(id);
+  if (childIdx === -1) {
+    throw Error("Something went wrong as parent didn't have child.");
+  } else {
+    newParentState.allChildren = [...newParentState.allChildren];
+    newParentState.allChildren[childIdx] = activityState;
+  }
+  const childActivities = newParentState.type === "sequence" ? [...newParentState.orderedChildren] : [...newParentState.selectedChildren];
+  const childIdx2 = childActivities.map((child) => child.id).indexOf(id);
+  if (childIdx2 === -1) {
+    throw Error(
+      "Something went wrong as parent didn't have child in last attempt."
+    );
+  }
+  childActivities[childIdx2] = activityState;
+  let creditAchieved;
+  if (newParentState.type === "sequence") {
+    newParentState.orderedChildren = childActivities;
+    const nonDescriptions = newParentState.allChildren.filter(
+      (activityState2) => activityState2.type !== "singleDoc" || !activityState2.source.isDescription
+    );
+    let creditWeights = [...newParentState.source.creditWeights ?? []];
+    if (creditWeights.length < nonDescriptions.length) {
+      creditWeights.push(
+        ...Array(
+          nonDescriptions.length - creditWeights.length
+        ).fill(1)
+      );
+    }
+    creditWeights = creditWeights.slice(0, nonDescriptions.length);
+    const totWeights = creditWeights.reduce((a, c) => a + c);
+    creditWeights = creditWeights.map((w) => w / totWeights);
+    creditAchieved = nonDescriptions.reduce(
+      (a, c, i) => a + c.creditAchieved * creditWeights[i],
+      0
+    );
+  } else {
+    newParentState.selectedChildren = childActivities;
+    creditAchieved = childActivities.reduce((a, c) => a + c.creditAchieved, 0) / childActivities.length;
+  }
+  newParentState.creditAchieved = creditAchieved;
+  return propagateStateChangeToRoot({
+    allStates,
+    id: newParentState.id
+  });
+}
+function removeVersionFromSource(source) {
+  if (source.type === "singleDoc") {
+    return {
+      ...source,
+      version: ""
+    };
+  } else {
+    return {
+      ...source,
+      items: source.items.map(removeVersionFromSource)
+    };
+  }
+}
+function createSourceHash(source) {
+  return hash(removeVersionFromSource(source));
+}
+function isSingleDocReportStateMessage(obj) {
+  const typedObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typedObj !== null && typeof typedObj === "object" && typeof typedObj.activityId === "string" && typeof typedObj.docId === "string" && typeof typedObj.score === "number"
+  );
+}
+function isRestrictToVariantSlice(obj) {
+  const typeObj = obj;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    typeObj !== null && typeof typeObj === "object" && typeof typeObj.idx === "number" && typeof typeObj.numSlices === "number"
+  );
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let nanoid = (size = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
+  }
+  return id;
+};
+var DefaultContext = {
+  color: void 0,
+  size: void 0,
+  className: void 0,
+  style: void 0,
+  attr: void 0
+};
+var IconContext = React.createContext && /* @__PURE__ */ React.createContext(DefaultContext);
+var _excluded = ["attr", "size", "title"];
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  for (var key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (excluded.indexOf(key) >= 0) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function Tree2Element(tree) {
+  return tree && tree.map((node, i) => /* @__PURE__ */ React.createElement(node.tag, _objectSpread({
+    key: i
+  }, node.attr), Tree2Element(node.child)));
+}
+function GenIcon(data) {
+  return (props) => /* @__PURE__ */ React.createElement(IconBase, _extends({
+    attr: _objectSpread({}, data.attr)
+  }, props), Tree2Element(data.child));
+}
+function IconBase(props) {
+  var elem = (conf) => {
+    var {
+      attr,
+      size,
+      title
+    } = props, svgProps = _objectWithoutProperties(props, _excluded);
+    var computedSize = size || conf.size || "1em";
+    var className;
+    if (conf.className) className = conf.className;
+    if (props.className) className = (className ? className + " " : "") + props.className;
+    return /* @__PURE__ */ React.createElement("svg", _extends({
+      stroke: "currentColor",
+      fill: "currentColor",
+      strokeWidth: "0"
+    }, conf.attr, attr, svgProps, {
+      className,
+      style: _objectSpread(_objectSpread({
+        color: props.color || conf.color
+      }, conf.style), props.style),
+      height: computedSize,
+      width: computedSize,
+      xmlns: "http://www.w3.org/2000/svg"
+    }), title && /* @__PURE__ */ React.createElement("title", null, title), props.children);
+  };
+  return IconContext !== void 0 ? /* @__PURE__ */ React.createElement(IconContext.Consumer, null, (conf) => elem(conf)) : elem(DefaultContext);
+}
+function MdError(props) {
+  return GenIcon({ "attr": { "viewBox": "0 0 24 24" }, "child": [{ "tag": "path", "attr": { "fill": "none", "d": "M0 0h24v24H0z" }, "child": [] }, { "tag": "path", "attr": { "d": "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-2h2v2zm0-4h-2V7h2v6z" }, "child": [] }] })(props);
+}
+function SelectActivity({
+  flags,
+  baseId,
+  maxAttemptsAllowed,
+  forceDisable = false,
+  forceShowCorrectness = false,
+  forceShowSolution = false,
+  forceUnsuppressCheckwork = false,
+  doenetViewerUrl,
+  fetchExternalDoenetML,
+  darkMode = "light",
+  showAnswerResponseMenu = false,
+  answerResponseCountsByItem = [],
+  state,
+  doenetStates,
+  loadedStateNum,
+  reportScoreAndStateCallback,
+  checkRender,
+  checkHidden,
+  allowItemAttemptButtons = false,
+  generateNewItemAttempt,
+  hasRenderedCallback,
+  reportVisibility = false,
+  reportVisibilityCallback,
+  itemAttemptNumbers,
+  itemSequence,
+  itemWord
+}) {
+  const selectedActivities = [];
+  const selectedIds = [];
+  for (const activity of state.selectedChildren) {
+    selectedActivities.push(
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        Activity,
+        {
+          state: activity,
+          doenetStates,
+          loadedStateNum,
+          flags,
+          baseId,
+          maxAttemptsAllowed,
+          forceDisable,
+          forceShowCorrectness,
+          forceShowSolution,
+          forceUnsuppressCheckwork,
+          doenetViewerUrl,
+          fetchExternalDoenetML,
+          darkMode,
+          showAnswerResponseMenu,
+          answerResponseCountsByItem,
+          reportScoreAndStateCallback,
+          checkRender,
+          checkHidden,
+          allowItemAttemptButtons,
+          generateNewItemAttempt,
+          hasRenderedCallback,
+          reportVisibility,
+          reportVisibilityCallback,
+          itemAttemptNumbers,
+          itemSequence,
+          itemWord
+        },
+        activity.id
+      )
+    );
+    selectedIds.push(activity.id);
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { hidden: !checkRender(state), children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: selectedActivities }) }, state.attemptNumber);
+}
+function SequenceActivity({
+  flags,
+  baseId,
+  maxAttemptsAllowed,
+  forceDisable = false,
+  forceShowCorrectness = false,
+  forceShowSolution = false,
+  forceUnsuppressCheckwork = false,
+  doenetViewerUrl,
+  fetchExternalDoenetML,
+  darkMode = "light",
+  showAnswerResponseMenu = false,
+  answerResponseCountsByItem = [],
+  state,
+  doenetStates,
+  loadedStateNum,
+  reportScoreAndStateCallback,
+  checkRender,
+  checkHidden,
+  allowItemAttemptButtons = false,
+  generateNewItemAttempt,
+  hasRenderedCallback,
+  reportVisibility = false,
+  reportVisibilityCallback,
+  itemAttemptNumbers,
+  itemSequence,
+  itemWord
+}) {
+  const activityList = [];
+  for (const activity of state.orderedChildren) {
+    activityList.push(
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        Activity,
+        {
+          state: activity,
+          doenetStates,
+          loadedStateNum,
+          flags,
+          baseId,
+          maxAttemptsAllowed,
+          forceDisable,
+          forceShowCorrectness,
+          forceShowSolution,
+          forceUnsuppressCheckwork,
+          doenetViewerUrl,
+          fetchExternalDoenetML,
+          darkMode,
+          showAnswerResponseMenu,
+          answerResponseCountsByItem,
+          reportScoreAndStateCallback,
+          checkRender,
+          checkHidden,
+          allowItemAttemptButtons,
+          generateNewItemAttempt,
+          hasRenderedCallback,
+          reportVisibility,
+          reportVisibilityCallback,
+          itemAttemptNumbers,
+          itemSequence,
+          itemWord
+        },
+        activity.id
+      )
+    );
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { hidden: !checkRender(state), children: activityList }, state.attemptNumber);
+}
+function SingleDocActivity({
+  flags,
+  baseId,
+  maxAttemptsAllowed,
+  forceDisable = false,
+  forceShowCorrectness = false,
+  forceShowSolution = false,
+  forceUnsuppressCheckwork = false,
+  doenetViewerUrl,
+  fetchExternalDoenetML,
+  darkMode = "light",
+  showAnswerResponseMenu = false,
+  answerResponseCountsByItem = [],
+  state,
+  doenetStates,
+  loadedStateNum,
+  reportScoreAndStateCallback,
+  checkRender,
+  checkHidden,
+  allowItemAttemptButtons = false,
+  generateNewItemAttempt,
+  hasRenderedCallback,
+  reportVisibility = false,
+  reportVisibilityCallback,
+  itemAttemptNumbers,
+  itemSequence,
+  itemWord
+}) {
+  const [rendered, setRendered] = useState(false);
+  const [attemptNumber, setAttemptNumber] = useState(state.attemptNumber);
+  const [loadedStateNumUsed, setLoadedStateNumUsed] = useState(0);
+  const [initialDoenetState, setInitialDoenetState] = useState(
+    state.doenetStateIdx === null ? null : doenetStates[state.doenetStateIdx] ?? null
+  );
+  console.log({
+    doenetStateIdx: state.doenetStateIdx,
+    resultingState: state.doenetStateIdx !== null && doenetStates[state.doenetStateIdx],
+    attemptNumber,
+    attemptNumberInState: state.attemptNumber,
+    loadedStateNum,
+    usedLoadedStateNum: loadedStateNumUsed
+  });
+  const [requestedVariantIndex, setRequestedVariantIndex] = useState(
+    state.currentVariant
+  );
+  const ref = useRef(null);
+  const itemIdx = useMemo(
+    () => itemSequence.indexOf(state.id),
+    [itemSequence, state.id]
+  );
+  const itemAttemptNumber = itemAttemptNumbers[itemIdx];
+  useEffect(() => {
+    if (reportVisibility && ref.current) {
+      const observer = new IntersectionObserver(
+        ([entry]) => {
+          reportVisibilityCallback(state.id, entry.isIntersecting);
+        },
+        { rootMargin: "1000px 1000px 1000px 1000px" }
+      );
+      observer.observe(ref.current);
+      return () => {
+        observer.disconnect();
+      };
+    }
+  }, [reportVisibility, ref, reportVisibilityCallback, state.id]);
+  if (state.attemptNumber !== attemptNumber || loadedStateNumUsed !== loadedStateNum) {
+    setAttemptNumber(state.attemptNumber);
+    setLoadedStateNumUsed(loadedStateNum);
+    setInitialDoenetState(
+      state.doenetStateIdx === null ? null : doenetStates[state.doenetStateIdx] ?? null
+    );
+    setRequestedVariantIndex(state.currentVariant);
+  }
+  const initialCounters = {
+    question: state.initialQuestionCounter,
+    problem: state.initialQuestionCounter,
+    exercise: state.initialQuestionCounter
+  };
+  const source = state.source;
+  const showAttemptButton = allowItemAttemptButtons && generateNewItemAttempt !== void 0 && !source.isDescription && maxAttemptsAllowed !== 1;
+  const render = checkRender(state);
+  const hidden = checkHidden(state);
+  const newAttemptsLeft = Math.max(maxAttemptsAllowed - itemAttemptNumber, 0);
+  const attemptButtonDisabled = maxAttemptsAllowed > 0 && newAttemptsLeft <= 0;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { ref, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { hidden: !render || hidden, style: { minHeight: "100px" }, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      DoenetViewer,
+      {
+        doenetML: source.doenetML,
+        doenetmlVersion: source.version,
+        render,
+        requestedVariantIndex,
+        flags,
+        activityId: baseId,
+        prefixForIds: state.id,
+        docId: state.id,
+        forceDisable,
+        forceShowCorrectness,
+        forceShowSolution,
+        forceUnsuppressCheckwork,
+        doenetViewerUrl,
+        fetchExternalDoenetML,
+        darkMode,
+        showAnswerResponseMenu,
+        answerResponseCounts: answerResponseCountsByItem[itemIdx],
+        addVirtualKeyboard: false,
+        initialState: initialDoenetState,
+        initializeCounters: initialCounters,
+        reportScoreAndStateCallback,
+        initializedCallback: () => {
+          setRendered(true);
+          hasRenderedCallback(state.id);
+        }
+      },
+      state.attemptNumber
+    ),
+    showAttemptButton ? /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "button",
+      {
+        hidden: !rendered,
+        onClick: () => {
+          generateNewItemAttempt(
+            state.id,
+            state.initialQuestionCounter
+          );
+        },
+        disabled: attemptButtonDisabled,
+        style: {
+          marginLeft: "20px",
+          backgroundColor: "rgb(237, 242, 247)",
+          opacity: attemptButtonDisabled ? 0.4 : "inherit",
+          borderRadius: "10px",
+          padding: "5px 20px",
+          cursor: attemptButtonDisabled ? "not-allowed" : "pointer"
+        },
+        children: [
+          "New ",
+          itemWord,
+          " attempt",
+          " ",
+          maxAttemptsAllowed > 0 ? `(${newAttemptsLeft.toString()} left)` : null
+        ]
+      }
+    ) : null
+  ] }) });
+}
+function Activity({
+  flags,
+  baseId,
+  maxAttemptsAllowed,
+  forceDisable = false,
+  forceShowCorrectness = false,
+  forceShowSolution = false,
+  forceUnsuppressCheckwork = false,
+  doenetViewerUrl,
+  fetchExternalDoenetML,
+  darkMode = "light",
+  showAnswerResponseMenu = false,
+  answerResponseCountsByItem = [],
+  state,
+  doenetStates,
+  loadedStateNum,
+  reportScoreAndStateCallback,
+  checkRender,
+  checkHidden,
+  allowItemAttemptButtons = false,
+  generateNewItemAttempt,
+  hasRenderedCallback,
+  reportVisibility = false,
+  reportVisibilityCallback,
+  itemAttemptNumbers,
+  itemSequence,
+  itemWord
+}) {
+  switch (state.type) {
+    case "singleDoc": {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        SingleDocActivity,
+        {
+          flags,
+          baseId,
+          maxAttemptsAllowed,
+          forceDisable,
+          forceShowCorrectness,
+          forceShowSolution,
+          forceUnsuppressCheckwork,
+          doenetViewerUrl,
+          fetchExternalDoenetML,
+          darkMode,
+          showAnswerResponseMenu,
+          answerResponseCountsByItem,
+          state,
+          doenetStates,
+          loadedStateNum,
+          reportScoreAndStateCallback,
+          checkRender,
+          checkHidden,
+          allowItemAttemptButtons,
+          generateNewItemAttempt,
+          hasRenderedCallback,
+          reportVisibility,
+          reportVisibilityCallback,
+          itemAttemptNumbers,
+          itemSequence,
+          itemWord
+        }
+      );
+    }
+    case "select": {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        SelectActivity,
+        {
+          flags,
+          baseId,
+          maxAttemptsAllowed,
+          forceDisable,
+          forceShowCorrectness,
+          forceShowSolution,
+          forceUnsuppressCheckwork,
+          doenetViewerUrl,
+          fetchExternalDoenetML,
+          darkMode,
+          showAnswerResponseMenu,
+          answerResponseCountsByItem,
+          state,
+          doenetStates,
+          loadedStateNum,
+          reportScoreAndStateCallback,
+          checkRender,
+          checkHidden,
+          allowItemAttemptButtons,
+          generateNewItemAttempt,
+          hasRenderedCallback,
+          reportVisibility,
+          reportVisibilityCallback,
+          itemAttemptNumbers,
+          itemSequence,
+          itemWord
+        }
+      );
+    }
+    case "sequence": {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        SequenceActivity,
+        {
+          flags,
+          baseId,
+          maxAttemptsAllowed,
+          forceDisable,
+          forceShowCorrectness,
+          forceShowSolution,
+          forceUnsuppressCheckwork,
+          doenetViewerUrl,
+          fetchExternalDoenetML,
+          darkMode,
+          showAnswerResponseMenu,
+          answerResponseCountsByItem,
+          state,
+          doenetStates,
+          loadedStateNum,
+          reportScoreAndStateCallback,
+          checkRender,
+          checkHidden,
+          allowItemAttemptButtons,
+          generateNewItemAttempt,
+          hasRenderedCallback,
+          reportVisibility,
+          reportVisibilityCallback,
+          itemAttemptNumbers,
+          itemSequence,
+          itemWord
+        }
+      );
+    }
+  }
+}
+function activityDoenetStateReducer(state, action) {
+  const activityState = state.activityState;
+  switch (action.type) {
+    case "initialize": {
+      const numItems = getNumItems(action.source);
+      return {
+        activityState: initializeActivityState({
+          source: action.source,
+          variant: action.variantIndex,
+          parentId: null,
+          numActivityVariants: action.numActivityVariants
+        }),
+        doenetStates: [],
+        itemAttemptNumbers: Array(numItems).fill(1)
+      };
+    }
+    case "set": {
+      if (action.allowSaveState) {
+        const itemScores = extractActivityItemCredit(
+          action.state.activityState
+        );
+        const message = {
+          score: action.state.activityState.creditAchieved,
+          item_scores: itemScores,
+          subject: "SPLICE.reportScoreByItem",
+          activity_id: action.baseId,
+          message_id: nanoid()
+        };
+        window.postMessage(message);
+      }
+      console.log("setting state to", action.state);
+      return action.state;
+    }
+    case "generateNewActivityAttempt": {
+      const { state: newActivityState } = generateNewActivityAttempt({
+        state: activityState,
+        numActivityVariants: action.numActivityVariants,
+        initialQuestionCounter: action.initialQuestionCounter,
+        parentAttempt: 1
+      });
+      const newItemAttemptNumbers = state.itemAttemptNumbers.map(() => 1);
+      if (action.allowSaveState && !action.initialAttempt) {
+        const itemScores = extractActivityItemCredit(newActivityState);
+        const message = {
+          state: {
+            activityState: pruneActivityStateForSave(newActivityState),
+            doenetStates: [],
+            itemAttemptNumbers: newItemAttemptNumbers,
+            sourceHash: action.sourceHash
+          },
+          score: newActivityState.creditAchieved,
+          item_scores: itemScores,
+          subject: "SPLICE.reportScoreAndState",
+          activity_id: action.baseId,
+          message_id: nanoid(),
+          new_attempt: true
+        };
+        window.postMessage(message);
+      }
+      return {
+        activityState: newActivityState,
+        doenetStates: [],
+        itemAttemptNumbers: newItemAttemptNumbers
+      };
+    }
+    case "generateSingleDocSubActivityAttempt": {
+      if (action.docId === activityState.id) {
+        throw Error(
+          "Should not call generateSingleDocSubActivityAttempt on entire activity"
+        );
+      }
+      const newActivityState = generateNewSingleDocSubAttempt({
+        singleDocId: action.docId,
+        state: activityState,
+        numActivityVariants: action.numActivityVariants,
+        initialQuestionCounter: action.initialQuestionCounter
+      });
+      const newDoenetMLStates = [...state.doenetStates];
+      newDoenetMLStates[action.doenetStateIdx] = null;
+      const itemIdx = action.itemSequence.indexOf(action.docId);
+      const newItemAttemptNumbers = [...state.itemAttemptNumbers];
+      newItemAttemptNumbers[itemIdx]++;
+      if (action.allowSaveState) {
+        const itemScores = extractActivityItemCredit(newActivityState);
+        const itemScoresOld = extractActivityItemCredit(activityState);
+        const newAttemptForItem = itemScoresOld.findIndex(
+          (s) => s.id === action.docId || s.docId === action.docId
+        ) + 1;
+        const message = {
+          state: {
+            activityState: pruneActivityStateForSave(newActivityState),
+            doenetStates: newDoenetMLStates,
+            itemAttemptNumbers: newItemAttemptNumbers,
+            sourceHash: action.sourceHash
+          },
+          score: newActivityState.creditAchieved,
+          item_scores: itemScores,
+          new_doenet_state_idx: action.doenetStateIdx,
+          subject: "SPLICE.reportScoreAndState",
+          activity_id: action.baseId,
+          message_id: nanoid(),
+          new_attempt: true,
+          new_attempt_for_item: newAttemptForItem
+        };
+        window.postMessage(message);
+      }
+      return {
+        activityState: newActivityState,
+        doenetStates: newDoenetMLStates,
+        itemAttemptNumbers: newItemAttemptNumbers
+      };
+    }
+    case "updateSingleState": {
+      console.log("updateSingleState", action, state);
+      const newActivityDoenetState = updateSingleDocState(action, state);
+      console.log({ newActivityDoenetState });
+      if (action.allowSaveState) {
+        const newActivityState = newActivityDoenetState.activityState;
+        const itemScores = extractActivityItemCredit(newActivityState);
+        const itemUpdated = action.itemSequence.indexOf(action.docId) + 1;
+        const message = {
+          state: {
+            activityState: pruneActivityStateForSave(newActivityState),
+            sourceHash: action.sourceHash,
+            doenetStates: newActivityDoenetState.doenetStates,
+            itemAttemptNumbers: state.itemAttemptNumbers
+          },
+          score: newActivityState.creditAchieved,
+          item_scores: itemScores,
+          item_updated: itemUpdated,
+          new_doenet_state_idx: action.doenetStateIdx,
+          subject: "SPLICE.reportScoreAndState",
+          activity_id: action.baseId,
+          message_id: nanoid()
+        };
+        window.postMessage(message);
+      }
+      return newActivityDoenetState;
+    }
+  }
+  throw Error("Invalid activity action");
+}
+function updateSingleDocState(action, activityDoenetState) {
+  const allStates = gatherStates(activityDoenetState.activityState);
+  const newSingleDocState = allStates[action.docId] = {
+    ...allStates[action.docId]
+  };
+  if (newSingleDocState.type !== "singleDoc") {
+    throw Error(
+      "Received the wrong type of activity for updateSingleDocState"
+    );
+  }
+  newSingleDocState.creditAchieved = action.creditAchieved;
+  const doenetStates = [...activityDoenetState.doenetStates];
+  doenetStates[action.doenetStateIdx] = action.doenetState;
+  newSingleDocState.doenetStateIdx = action.doenetStateIdx;
+  const rootActivityState = propagateStateChangeToRoot({
+    allStates,
+    id: newSingleDocState.id
+  });
+  return {
+    activityState: rootActivityState,
+    doenetStates,
+    itemAttemptNumbers: activityDoenetState.itemAttemptNumbers
+  };
+}
+function Viewer({
+  source,
+  flags,
+  activityId,
+  userId = null,
+  initialVariantIndex,
+  maxAttemptsAllowed = 1,
+  itemLevelAttempts = false,
+  activityLevelAttempts = false,
+  paginate = true,
+  showFinishButton: _showFinishButton = false,
+  forceDisable = false,
+  forceShowCorrectness = false,
+  forceShowSolution = false,
+  forceUnsuppressCheckwork = false,
+  addVirtualKeyboard: _addVirtualKeyboard = true,
+  externalVirtualKeyboardProvided: _externalVirtualKeyboardProvided = false,
+  doenetViewerUrl,
+  fetchExternalDoenetML,
+  darkMode = "light",
+  showAnswerResponseMenu = false,
+  answerResponseCountsByItem = [],
+  showTitle = true,
+  itemWord = "item"
+}) {
+  const [errMsg, setErrMsg] = useState(null);
+  const initialPass = useRef(true);
+  const { numActivityVariants, sourceHash, numItems } = useMemo(() => {
+    try {
+      validateIds(source);
+      const docStructure = gatherDocumentStructure(source);
+      const sourceHash2 = createSourceHash(source);
+      const numItems2 = getNumItems(source);
+      return { ...docStructure, sourceHash: sourceHash2, numItems: numItems2 };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "";
+      setErrMsg(`Error in activity source: ${message}`);
+      return {
+        numActivityVariants: {},
+        sourceHash: "",
+        numItems: 0
+      };
+    }
+  }, [source]);
+  const [activityDoenetState, activityDoenetStateDispatch] = useReducer(
+    activityDoenetStateReducer,
+    {
+      source,
+      variant: initialVariantIndex,
+      parentId: null,
+      numActivityVariants
+    },
+    initializeActivityAndDoenetState
+  );
+  const [loadedStateNum, setLoadedStateNum] = useState(0);
+  console.log({ activityDoenetState });
+  const activityState = activityDoenetState.activityState;
+  const itemSequence = getItemSequence(activityState);
+  const [currentItemIdx, setCurrentItemIdx] = useState(0);
+  const currentItemId = itemSequence[currentItemIdx];
+  const [itemsRendered, setItemsRendered] = useState([]);
+  const [itemsToRender, setItemsToRender] = useState([]);
+  const [itemsVisible, setItemsVisible] = useState([]);
+  const [newAttemptNum, setNewAttemptNum] = useState(0);
+  const dialogRef = useRef(null);
+  const newItemAttemptInfo = useRef({ id: "", initialQuestionCounter: 0 });
+  const attemptNumber = activityState.attemptNumber;
+  function addItemToRender(id) {
+    if (!itemsToRender.includes(id)) {
+      setItemsToRender((was) => {
+        if (was.includes(id)) {
+          return was;
+        }
+        const obj = [...was];
+        obj.push(id);
+        return obj;
+      });
+    }
+  }
+  const checkRender = useCallback(
+    (state) => {
+      if (state.type === "singleDoc") {
+        return itemsToRender.includes(state.id);
+      } else {
+        return true;
+      }
+    },
+    [itemsToRender]
+  );
+  const checkHidden = useCallback(
+    (state) => {
+      if (state.type === "singleDoc") {
+        return paginate && currentItemId !== state.id;
+      } else {
+        return false;
+      }
+    },
+    [currentItemId, paginate]
+  );
+  useEffect(() => {
+    if (initialPass.current) {
+      initialPass.current = false;
+    } else {
+      activityDoenetStateDispatch({
+        type: "initialize",
+        source,
+        variantIndex: initialVariantIndex,
+        numActivityVariants
+      });
+    }
+  }, [activityId, source, initialVariantIndex, numActivityVariants]);
+  useEffect(() => {
+    const listenersAdded = [];
+    function requestLoadState() {
+      const message_id = nanoid();
+      window.postMessage({
+        subject: "SPLICE.getState",
+        message_id,
+        activity_id: activityId,
+        user_id: userId
+      });
+      const loadStateListener = function(event) {
+        if (event.origin !== window.location.origin) {
+          return;
+        }
+        if (event.data.subject === "SPLICE.getState.response" && event.data.message_id === message_id) {
+          console.log("received getState.response");
+          const exportedState = event.data.state;
+          if (isExportedActivityState(exportedState)) {
+            console.log("It's exported state");
+            if (validateStateAndSource(exportedState, source)) {
+              const state = addSourceToActivityState(
+                exportedState.activityState,
+                source
+              );
+              console.log("validated!");
+              activityDoenetStateDispatch({
+                type: "set",
+                state: {
+                  activityState: state,
+                  doenetStates: exportedState.doenetStates,
+                  itemAttemptNumbers: exportedState.itemAttemptNumbers
+                },
+                allowSaveState: flags.allowSaveState,
+                baseId: activityId
+              });
+              setLoadedStateNum((was) => was + 1);
+            }
+          }
+          window.removeEventListener("message", loadStateListener);
+        }
+      };
+      window.addEventListener("message", loadStateListener);
+      listenersAdded.push(loadStateListener);
+    }
+    try {
+      activityDoenetStateDispatch({
+        type: "generateNewActivityAttempt",
+        numActivityVariants,
+        initialQuestionCounter: 1,
+        allowSaveState: flags.allowSaveState,
+        baseId: activityId,
+        sourceHash,
+        initialAttempt: true
+      });
+      setLoadedStateNum((was) => was + 1);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "";
+      setErrMsg(`Error in activity: ${message}`);
+    }
+    if (flags.allowLoadState) {
+      requestLoadState();
+    }
+    return () => {
+      for (const listener of listenersAdded) {
+        window.removeEventListener("message", listener);
+      }
+    };
+  }, [
+    flags.allowLoadState,
+    flags.allowSaveState,
+    activityId,
+    userId,
+    source,
+    numActivityVariants,
+    sourceHash
+  ]);
+  function clickNext() {
+    setCurrentItemIdx((was) => Math.min(numItems - 1, was + 1));
+  }
+  function clickPrevious() {
+    setCurrentItemIdx((was) => Math.max(0, was - 1));
+  }
+  function reportScoreAndStateCallback(msg) {
+    console.log("reportScoreAndStateCallback!!!!", msg);
+    if (isSingleDocReportStateMessage(msg)) {
+      activityDoenetStateDispatch({
+        type: "updateSingleState",
+        docId: msg.docId,
+        doenetState: msg.state,
+        doenetStateIdx: itemSequence.indexOf(msg.docId),
+        itemSequence,
+        creditAchieved: msg.score,
+        allowSaveState: flags.allowSaveState,
+        baseId: activityId,
+        sourceHash
+      });
+    }
+  }
+  function generateNewItemAttemptPrompt(id, initialQuestionCounter) {
+    newItemAttemptInfo.current = { id, initialQuestionCounter };
+    setNewAttemptNum((itemSequence.indexOf(id) ?? 0) + 1);
+    dialogRef.current?.showModal();
+  }
+  function generateNewItemAttempt() {
+    const { id, initialQuestionCounter } = newItemAttemptInfo.current;
+    activityDoenetStateDispatch({
+      type: "generateSingleDocSubActivityAttempt",
+      docId: id,
+      doenetStateIdx: itemSequence.indexOf(id),
+      itemSequence,
+      numActivityVariants,
+      initialQuestionCounter,
+      allowSaveState: flags.allowSaveState,
+      baseId: activityId,
+      sourceHash
+    });
+    setItemsRendered((was) => {
+      const idx = was.indexOf(id);
+      if (idx === -1) {
+        return was;
+      } else {
+        const arr = [...was];
+        arr.splice(idx, 1);
+        return arr;
+      }
+    });
+    setItemsToRender((was) => {
+      const idx = was.indexOf(id);
+      if (idx === -1) {
+        return was;
+      } else {
+        const arr = [...was];
+        arr.splice(idx, 1);
+        return arr;
+      }
+    });
+  }
+  function hasRenderedCallback(id) {
+    setItemsRendered((was) => {
+      if (was.includes(id)) {
+        return was;
+      }
+      const obj = [...was];
+      obj.push(id);
+      return obj;
+    });
+  }
+  function reportVisibilityCallback(id, isVisible) {
+    setItemsVisible((was) => {
+      if (isVisible) {
+        if (was.includes(id)) {
+          return was;
+        } else {
+          const obj = [...was];
+          obj.push(id);
+          return obj;
+        }
+      } else {
+        const idx = was.indexOf(id);
+        if (idx === -1) {
+          return was;
+        } else {
+          const obj = [...was];
+          obj.splice(idx, 1);
+          return obj;
+        }
+      }
+    });
+  }
+  function generateActivityAttempt() {
+    setItemsRendered([]);
+    setItemsToRender([]);
+    setCurrentItemIdx(0);
+    activityDoenetStateDispatch({
+      type: "generateNewActivityAttempt",
+      numActivityVariants,
+      initialQuestionCounter: 1,
+      allowSaveState: flags.allowSaveState,
+      baseId: activityId,
+      sourceHash
+    });
+  }
+  if (errMsg !== null) {
+    const errorIcon = /* @__PURE__ */ jsxRuntimeExports.jsx("span", { style: { fontSize: "1em", color: "#C1292E" }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(MdError, {}) });
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      "div",
+      {
+        style: {
+          fontSize: "1.3em",
+          marginLeft: "20px",
+          marginTop: "20px"
+        },
+        children: [
+          errorIcon,
+          " ",
+          errMsg
+        ]
+      }
+    );
+  }
+  if (paginate) {
+    if (!itemsRendered.includes(currentItemId)) {
+      addItemToRender(currentItemId);
+    } else {
+      const nextItemId = itemSequence[currentItemIdx + 1];
+      if (currentItemIdx < numItems - 1 && !itemsRendered.includes(nextItemId)) {
+        addItemToRender(nextItemId);
+      } else {
+        const prevItemId = itemSequence[currentItemIdx - 1];
+        if (currentItemIdx > 0 && !itemsRendered.includes(prevItemId)) {
+          addItemToRender(prevItemId);
+        }
+      }
+    }
+  } else {
+    for (const id of itemSequence) {
+      if (!itemsRendered.includes(id) && itemsVisible.includes(id)) {
+        addItemToRender(id);
+        break;
+      }
+    }
+  }
+  const activityAttemptsLeft = Math.max(
+    maxAttemptsAllowed - attemptNumber,
+    0
+  );
+  const newAttemptsLeft = newAttemptNum === 0 ? activityAttemptsLeft : Math.max(
+    maxAttemptsAllowed - activityDoenetState.itemAttemptNumbers[newAttemptNum - 1],
+    0
+  );
+  const newAttemptDisabled = numItems === 0 || maxAttemptsAllowed > 0 && activityAttemptsLeft <= 0;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("dialog", { ref: dialogRef, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("h3", { children: [
+        "Create new attempt of",
+        " ",
+        newAttemptNum === 0 ? "the entire activity" : `${itemWord} ${newAttemptNum.toString()}`,
+        "?"
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { children: [
+        "Creating a new attempt will generate",
+        " ",
+        newAttemptNum === 0 ? `new versions of all ${itemWord}s so that you can start again at the beginning.` : `a new version of ${itemWord} ${newAttemptNum.toString()} so that you can start that ${itemWord} again.`
+      ] }),
+      maxAttemptsAllowed > 0 ? /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { children: [
+        "You can create a new attempt",
+        " ",
+        newAttemptsLeft.toString(),
+        " more time",
+        newAttemptsLeft > 1 ? "s" : "",
+        "."
+      ] }) : null,
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { style: { marginTop: "30px" }, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            autoFocus: true,
+            onClick: () => {
+              dialogRef.current?.close();
+            },
+            style: {
+              marginLeft: "30px",
+              backgroundColor: "lightgray",
+              borderRadius: "10px",
+              padding: "5px 20px"
+            },
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            onClick: () => {
+              if (newAttemptNum === 0) {
+                generateActivityAttempt();
+              } else {
+                generateNewItemAttempt();
+              }
+              dialogRef.current?.close();
+            },
+            style: {
+              marginLeft: "30px",
+              backgroundColor: "lightgray",
+              borderRadius: "10px",
+              padding: "5px 20px"
+            },
+            children: "Create new attempt"
+          }
+        )
+      ] })
+    ] }),
+    showTitle ? /* @__PURE__ */ jsxRuntimeExports.jsx("h2", { style: { marginLeft: "20px" }, children: source.title }) : null,
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { marginTop: "5px" }, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { hidden: !paginate, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            onClick: clickPrevious,
+            style: {
+              marginLeft: "20px",
+              marginRight: "10px",
+              backgroundColor: "lightgray",
+              borderRadius: "10px",
+              padding: "5px 20px"
+            },
+            disabled: currentItemIdx <= 0,
+            children: "Previous"
+          }
+        ),
+        "Page ",
+        currentItemIdx + 1,
+        " of ",
+        numItems,
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            onClick: clickNext,
+            style: {
+              marginLeft: "10px",
+              backgroundColor: "lightgray",
+              borderRadius: "10px",
+              padding: "5px 20px"
+            },
+            disabled: currentItemIdx >= numItems - 1,
+            children: "Next"
+          }
+        )
+      ] }),
+      activityLevelAttempts && maxAttemptsAllowed !== 1 ? /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        "button",
+        {
+          onClick: () => {
+            setNewAttemptNum(0);
+            dialogRef.current?.showModal();
+          },
+          disabled: newAttemptDisabled,
+          style: {
+            marginLeft: "30px",
+            backgroundColor: "rgb(237, 242, 247)",
+            opacity: newAttemptDisabled ? 0.4 : "inherit",
+            borderRadius: "10px",
+            padding: "5px 20px",
+            cursor: newAttemptDisabled ? "not-allowed" : "pointer"
+          },
+          children: [
+            "New attempt",
+            " ",
+            maxAttemptsAllowed > 0 ? `(${activityAttemptsLeft.toString()} left)` : null
+          ]
+        }
+      ) : null
+    ] }) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      "div",
+      {
+        hidden: itemsRendered.length > 0 || numItems === 0,
+        style: { marginLeft: "20px", marginTop: "20px" },
+        children: "Initializing..."
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Activity,
+      {
+        flags,
+        baseId: activityId,
+        maxAttemptsAllowed,
+        forceDisable,
+        forceShowCorrectness,
+        forceShowSolution,
+        forceUnsuppressCheckwork,
+        doenetViewerUrl,
+        fetchExternalDoenetML,
+        darkMode,
+        showAnswerResponseMenu,
+        answerResponseCountsByItem,
+        state: activityState,
+        doenetStates: activityDoenetState.doenetStates,
+        loadedStateNum,
+        reportScoreAndStateCallback,
+        checkRender,
+        checkHidden,
+        allowItemAttemptButtons: itemLevelAttempts,
+        generateNewItemAttempt: generateNewItemAttemptPrompt,
+        hasRenderedCallback,
+        reportVisibility: !paginate,
+        reportVisibilityCallback,
+        itemAttemptNumbers: activityDoenetState.itemAttemptNumbers,
+        itemSequence,
+        itemWord
+      }
+    )
+  ] });
+}
+const defaultFlags = {
+  showCorrectness: true,
+  readOnly: false,
+  solutionDisplayMode: "button",
+  showFeedback: true,
+  showHints: true,
+  allowLoadState: false,
+  allowSaveState: false,
+  allowLocalState: false,
+  allowSaveSubmissions: false,
+  allowSaveEvents: false,
+  autoSubmit: false
+};
+const rngClass = seedrandom.alea;
+function ActivityViewer({
+  source,
+  flags: specifiedFlags = {},
+  activityId = "a",
+  userId = null,
+  requestedVariantIndex,
+  maxAttemptsAllowed = 1,
+  itemLevelAttempts = false,
+  activityLevelAttempts = false,
+  paginate = true,
+  showFinishButton = false,
+  forceDisable = false,
+  forceShowCorrectness = false,
+  forceShowSolution = false,
+  forceUnsuppressCheckwork = false,
+  addVirtualKeyboard = true,
+  externalVirtualKeyboardProvided = false,
+  doenetViewerUrl,
+  fetchExternalDoenetML,
+  darkMode = "light",
+  showAnswerResponseMenu = false,
+  answerResponseCountsByItem = [],
+  includeVariantSelector: _includeVariantSelector = false,
+  showTitle = true,
+  itemWord = "item"
+}) {
+  const [initialVariantIndex, setInitialVariantIndex] = useState(null);
+  const thisPropSet = {
+    source: JSON.stringify(source),
+    activityId,
+    requestedVariantIndex
+  };
+  const lastPropSet = useRef({ source: "" });
+  const flags = { ...defaultFlags, ...specifiedFlags };
+  let foundPropChange = false;
+  let key;
+  for (key in thisPropSet) {
+    if (thisPropSet[key] !== lastPropSet.current[key]) {
+      foundPropChange = true;
+    }
+  }
+  lastPropSet.current = thisPropSet;
+  if (foundPropChange) {
+    if (requestedVariantIndex === void 0) {
+      const rng = rngClass((/* @__PURE__ */ new Date()).toString());
+      setInitialVariantIndex(Math.floor(rng() * 1e6) + 1);
+    } else {
+      setInitialVariantIndex(
+        Number.isInteger(requestedVariantIndex) ? requestedVariantIndex : 1
+      );
+    }
+  }
+  if (initialVariantIndex === null) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(ErrorBoundary, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+    Viewer,
+    {
+      source,
+      flags,
+      activityId,
+      userId,
+      initialVariantIndex,
+      maxAttemptsAllowed,
+      itemLevelAttempts,
+      activityLevelAttempts,
+      paginate,
+      showFinishButton,
+      forceDisable,
+      forceShowCorrectness,
+      forceShowSolution,
+      forceUnsuppressCheckwork,
+      addVirtualKeyboard,
+      externalVirtualKeyboardProvided,
+      doenetViewerUrl,
+      fetchExternalDoenetML,
+      darkMode,
+      showAnswerResponseMenu,
+      answerResponseCountsByItem,
+      showTitle,
+      itemWord
+    }
+  ) });
+}
+class ErrorBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, message: "" };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, message: error.message };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("Uncaught error", error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { marginLeft: "20px" }, children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("h1", { children: "An error occurred" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: this.state.message })
+      ] });
+    }
+    return this.props.children;
+  }
+}
+export {
+  ActivityViewer,
+  isActivitySource
+};