scratch-storage 5.0.11 → 6.0.1

package/dist/node/scratch-storage.js

@@ -2818,816 +2818,6 @@ f.subarray(0,c):f.slice(0,c)};E||(r.TextDecoder=x,r.TextEncoder=y)})(""+void 0==
 
 module.exports = __webpack_require__(14)("PD94bWwgdmVyc2lvbj0iMS4wIj8+Cjxzdmcgd2lkdGg9IjEyOCIgaGVpZ2h0PSIxMjgiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6c3ZnPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CiA8Zz4KICA8cmVjdCBmaWxsPSIjQ0NDIiBoZWlnaHQ9IjEyOCIgd2lkdGg9IjEyOCIvPgogIDx0ZXh0IGZpbGw9ImJsYWNrIiB5PSIxMDciIHg9IjM1LjUiIGZvbnQtc2l6ZT0iMTI4Ij4/PC90ZXh0PgogPC9nPgo8L3N2Zz4K")
 
-/***/ },
-
-/***/ 945
-(module, exports, __webpack_require__) {
-
-// Save global object in a variable
-var __global__ =
-(typeof globalThis !== 'undefined' && globalThis) ||
-(typeof self !== 'undefined' && self) ||
-(typeof __webpack_require__.g !== 'undefined' && __webpack_require__.g);
-// Create an object that extends from __global__ without the fetch function
-var __globalThis__ = (function () {
-function F() {
-this.fetch = false;
-this.DOMException = __global__.DOMException
-}
-F.prototype = __global__; // Needed for feature detection on whatwg-fetch's code
-return new F();
-})();
-// Wraps whatwg-fetch with a function scope to hijack the global object
-// "globalThis" that's going to be patched
-(function(globalThis) {
-
-var irrelevant = (function (exports) {
-
-  /* eslint-disable no-prototype-builtins */
-  var g =
-    (typeof globalThis !== 'undefined' && globalThis) ||
-    (typeof self !== 'undefined' && self) ||
-    // eslint-disable-next-line no-undef
-    (typeof __webpack_require__.g !== 'undefined' && __webpack_require__.g) ||
-    {};
-
-  var support = {
-    searchParams: 'URLSearchParams' in g,
-    iterable: 'Symbol' in g && 'iterator' in Symbol,
-    blob:
-      'FileReader' in g &&
-      'Blob' in g &&
-      (function() {
-        try {
-          new Blob();
-          return true
-        } catch (e) {
-          return false
-        }
-      })(),
-    formData: 'FormData' in g,
-    arrayBuffer: 'ArrayBuffer' in g
-  };
-
-  function isDataView(obj) {
-    return obj && DataView.prototype.isPrototypeOf(obj)
-  }
-
-  if (support.arrayBuffer) {
-    var viewClasses = [
-      '[object Int8Array]',
-      '[object Uint8Array]',
-      '[object Uint8ClampedArray]',
-      '[object Int16Array]',
-      '[object Uint16Array]',
-      '[object Int32Array]',
-      '[object Uint32Array]',
-      '[object Float32Array]',
-      '[object Float64Array]'
-    ];
-
-    var isArrayBufferView =
-      ArrayBuffer.isView ||
-      function(obj) {
-        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
-      };
-  }
-
-  function normalizeName(name) {
-    if (typeof name !== 'string') {
-      name = String(name);
-    }
-    if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
-      throw new TypeError('Invalid character in header field name: "' + name + '"')
-    }
-    return name.toLowerCase()
-  }
-
-  function normalizeValue(value) {
-    if (typeof value !== 'string') {
-      value = String(value);
-    }
-    return value
-  }
-
-  // Build a destructive iterator for the value list
-  function iteratorFor(items) {
-    var iterator = {
-      next: function() {
-        var value = items.shift();
-        return {done: value === undefined, value: value}
-      }
-    };
-
-    if (support.iterable) {
-      iterator[Symbol.iterator] = function() {
-        return iterator
-      };
-    }
-
-    return iterator
-  }
-
-  function Headers(headers) {
-    this.map = {};
-
-    if (headers instanceof Headers) {
-      headers.forEach(function(value, name) {
-        this.append(name, value);
-      }, this);
-    } else if (Array.isArray(headers)) {
-      headers.forEach(function(header) {
-        if (header.length != 2) {
-          throw new TypeError('Headers constructor: expected name/value pair to be length 2, found' + header.length)
-        }
-        this.append(header[0], header[1]);
-      }, this);
-    } else if (headers) {
-      Object.getOwnPropertyNames(headers).forEach(function(name) {
-        this.append(name, headers[name]);
-      }, this);
-    }
-  }
-
-  Headers.prototype.append = function(name, value) {
-    name = normalizeName(name);
-    value = normalizeValue(value);
-    var oldValue = this.map[name];
-    this.map[name] = oldValue ? oldValue + ', ' + value : value;
-  };
-
-  Headers.prototype['delete'] = function(name) {
-    delete this.map[normalizeName(name)];
-  };
-
-  Headers.prototype.get = function(name) {
-    name = normalizeName(name);
-    return this.has(name) ? this.map[name] : null
-  };
-
-  Headers.prototype.has = function(name) {
-    return this.map.hasOwnProperty(normalizeName(name))
-  };
-
-  Headers.prototype.set = function(name, value) {
-    this.map[normalizeName(name)] = normalizeValue(value);
-  };
-
-  Headers.prototype.forEach = function(callback, thisArg) {
-    for (var name in this.map) {
-      if (this.map.hasOwnProperty(name)) {
-        callback.call(thisArg, this.map[name], name, this);
-      }
-    }
-  };
-
-  Headers.prototype.keys = function() {
-    var items = [];
-    this.forEach(function(value, name) {
-      items.push(name);
-    });
-    return iteratorFor(items)
-  };
-
-  Headers.prototype.values = function() {
-    var items = [];
-    this.forEach(function(value) {
-      items.push(value);
-    });
-    return iteratorFor(items)
-  };
-
-  Headers.prototype.entries = function() {
-    var items = [];
-    this.forEach(function(value, name) {
-      items.push([name, value]);
-    });
-    return iteratorFor(items)
-  };
-
-  if (support.iterable) {
-    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
-  }
-
-  function consumed(body) {
-    if (body._noBody) return
-    if (body.bodyUsed) {
-      return Promise.reject(new TypeError('Already read'))
-    }
-    body.bodyUsed = true;
-  }
-
-  function fileReaderReady(reader) {
-    return new Promise(function(resolve, reject) {
-      reader.onload = function() {
-        resolve(reader.result);
-      };
-      reader.onerror = function() {
-        reject(reader.error);
-      };
-    })
-  }
-
-  function readBlobAsArrayBuffer(blob) {
-    var reader = new FileReader();
-    var promise = fileReaderReady(reader);
-    reader.readAsArrayBuffer(blob);
-    return promise
-  }
-
-  function readBlobAsText(blob) {
-    var reader = new FileReader();
-    var promise = fileReaderReady(reader);
-    var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
-    var encoding = match ? match[1] : 'utf-8';
-    reader.readAsText(blob, encoding);
-    return promise
-  }
-
-  function readArrayBufferAsText(buf) {
-    var view = new Uint8Array(buf);
-    var chars = new Array(view.length);
-
-    for (var i = 0; i < view.length; i++) {
-      chars[i] = String.fromCharCode(view[i]);
-    }
-    return chars.join('')
-  }
-
-  function bufferClone(buf) {
-    if (buf.slice) {
-      return buf.slice(0)
-    } else {
-      var view = new Uint8Array(buf.byteLength);
-      view.set(new Uint8Array(buf));
-      return view.buffer
-    }
-  }
-
-  function Body() {
-    this.bodyUsed = false;
-
-    this._initBody = function(body) {
-      /*
-        fetch-mock wraps the Response object in an ES6 Proxy to
-        provide useful test harness features such as flush. However, on
-        ES5 browsers without fetch or Proxy support pollyfills must be used;
-        the proxy-pollyfill is unable to proxy an attribute unless it exists
-        on the object before the Proxy is created. This change ensures
-        Response.bodyUsed exists on the instance, while maintaining the
-        semantic of setting Request.bodyUsed in the constructor before
-        _initBody is called.
-      */
-      // eslint-disable-next-line no-self-assign
-      this.bodyUsed = this.bodyUsed;
-      this._bodyInit = body;
-      if (!body) {
-        this._noBody = true;
-        this._bodyText = '';
-      } else if (typeof body === 'string') {
-        this._bodyText = body;
-      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
-        this._bodyBlob = body;
-      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
-        this._bodyFormData = body;
-      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-        this._bodyText = body.toString();
-      } else if (support.arrayBuffer && support.blob && isDataView(body)) {
-        this._bodyArrayBuffer = bufferClone(body.buffer);
-        // IE 10-11 can't handle a DataView body.
-        this._bodyInit = new Blob([this._bodyArrayBuffer]);
-      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
-        this._bodyArrayBuffer = bufferClone(body);
-      } else {
-        this._bodyText = body = Object.prototype.toString.call(body);
-      }
-
-      if (!this.headers.get('content-type')) {
-        if (typeof body === 'string') {
-          this.headers.set('content-type', 'text/plain;charset=UTF-8');
-        } else if (this._bodyBlob && this._bodyBlob.type) {
-          this.headers.set('content-type', this._bodyBlob.type);
-        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
-          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
-        }
-      }
-    };
-
-    if (support.blob) {
-      this.blob = function() {
-        var rejected = consumed(this);
-        if (rejected) {
-          return rejected
-        }
-
-        if (this._bodyBlob) {
-          return Promise.resolve(this._bodyBlob)
-        } else if (this._bodyArrayBuffer) {
-          return Promise.resolve(new Blob([this._bodyArrayBuffer]))
-        } else if (this._bodyFormData) {
-          throw new Error('could not read FormData body as blob')
-        } else {
-          return Promise.resolve(new Blob([this._bodyText]))
-        }
-      };
-    }
-
-    this.arrayBuffer = function() {
-      if (this._bodyArrayBuffer) {
-        var isConsumed = consumed(this);
-        if (isConsumed) {
-          return isConsumed
-        } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
-          return Promise.resolve(
-            this._bodyArrayBuffer.buffer.slice(
-              this._bodyArrayBuffer.byteOffset,
-              this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
-            )
-          )
-        } else {
-          return Promise.resolve(this._bodyArrayBuffer)
-        }
-      } else if (support.blob) {
-        return this.blob().then(readBlobAsArrayBuffer)
-      } else {
-        throw new Error('could not read as ArrayBuffer')
-      }
-    };
-
-    this.text = function() {
-      var rejected = consumed(this);
-      if (rejected) {
-        return rejected
-      }
-
-      if (this._bodyBlob) {
-        return readBlobAsText(this._bodyBlob)
-      } else if (this._bodyArrayBuffer) {
-        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
-      } else if (this._bodyFormData) {
-        throw new Error('could not read FormData body as text')
-      } else {
-        return Promise.resolve(this._bodyText)
-      }
-    };
-
-    if (support.formData) {
-      this.formData = function() {
-        return this.text().then(decode)
-      };
-    }
-
-    this.json = function() {
-      return this.text().then(JSON.parse)
-    };
-
-    return this
-  }
-
-  // HTTP methods whose capitalization should be normalized
-  var methods = ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE'];
-
-  function normalizeMethod(method) {
-    var upcased = method.toUpperCase();
-    return methods.indexOf(upcased) > -1 ? upcased : method
-  }
-
-  function Request(input, options) {
-    if (!(this instanceof Request)) {
-      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
-    }
-
-    options = options || {};
-    var body = options.body;
-
-    if (input instanceof Request) {
-      if (input.bodyUsed) {
-        throw new TypeError('Already read')
-      }
-      this.url = input.url;
-      this.credentials = input.credentials;
-      if (!options.headers) {
-        this.headers = new Headers(input.headers);
-      }
-      this.method = input.method;
-      this.mode = input.mode;
-      this.signal = input.signal;
-      if (!body && input._bodyInit != null) {
-        body = input._bodyInit;
-        input.bodyUsed = true;
-      }
-    } else {
-      this.url = String(input);
-    }
-
-    this.credentials = options.credentials || this.credentials || 'same-origin';
-    if (options.headers || !this.headers) {
-      this.headers = new Headers(options.headers);
-    }
-    this.method = normalizeMethod(options.method || this.method || 'GET');
-    this.mode = options.mode || this.mode || null;
-    this.signal = options.signal || this.signal || (function () {
-      if ('AbortController' in g) {
-        var ctrl = new AbortController();
-        return ctrl.signal;
-      }
-    }());
-    this.referrer = null;
-
-    if ((this.method === 'GET' || this.method === 'HEAD') && body) {
-      throw new TypeError('Body not allowed for GET or HEAD requests')
-    }
-    this._initBody(body);
-
-    if (this.method === 'GET' || this.method === 'HEAD') {
-      if (options.cache === 'no-store' || options.cache === 'no-cache') {
-        // Search for a '_' parameter in the query string
-        var reParamSearch = /([?&])_=[^&]*/;
-        if (reParamSearch.test(this.url)) {
-          // If it already exists then set the value with the current time
-          this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
-        } else {
-          // Otherwise add a new '_' parameter to the end with the current time
-          var reQueryString = /\?/;
-          this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
-        }
-      }
-    }
-  }
-
-  Request.prototype.clone = function() {
-    return new Request(this, {body: this._bodyInit})
-  };
-
-  function decode(body) {
-    var form = new FormData();
-    body
-      .trim()
-      .split('&')
-      .forEach(function(bytes) {
-        if (bytes) {
-          var split = bytes.split('=');
-          var name = split.shift().replace(/\+/g, ' ');
-          var value = split.join('=').replace(/\+/g, ' ');
-          form.append(decodeURIComponent(name), decodeURIComponent(value));
-        }
-      });
-    return form
-  }
-
-  function parseHeaders(rawHeaders) {
-    var headers = new Headers();
-    // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
-    // https://tools.ietf.org/html/rfc7230#section-3.2
-    var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
-    // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
-    // https://github.com/github/fetch/issues/748
-    // https://github.com/zloirock/core-js/issues/751
-    preProcessedHeaders
-      .split('\r')
-      .map(function(header) {
-        return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
-      })
-      .forEach(function(line) {
-        var parts = line.split(':');
-        var key = parts.shift().trim();
-        if (key) {
-          var value = parts.join(':').trim();
-          try {
-            headers.append(key, value);
-          } catch (error) {
-            console.warn('Response ' + error.message);
-          }
-        }
-      });
-    return headers
-  }
-
-  Body.call(Request.prototype);
-
-  function Response(bodyInit, options) {
-    if (!(this instanceof Response)) {
-      throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
-    }
-    if (!options) {
-      options = {};
-    }
-
-    this.type = 'default';
-    this.status = options.status === undefined ? 200 : options.status;
-    if (this.status < 200 || this.status > 599) {
-      throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].")
-    }
-    this.ok = this.status >= 200 && this.status < 300;
-    this.statusText = options.statusText === undefined ? '' : '' + options.statusText;
-    this.headers = new Headers(options.headers);
-    this.url = options.url || '';
-    this._initBody(bodyInit);
-  }
-
-  Body.call(Response.prototype);
-
-  Response.prototype.clone = function() {
-    return new Response(this._bodyInit, {
-      status: this.status,
-      statusText: this.statusText,
-      headers: new Headers(this.headers),
-      url: this.url
-    })
-  };
-
-  Response.error = function() {
-    var response = new Response(null, {status: 200, statusText: ''});
-    response.ok = false;
-    response.status = 0;
-    response.type = 'error';
-    return response
-  };
-
-  var redirectStatuses = [301, 302, 303, 307, 308];
-
-  Response.redirect = function(url, status) {
-    if (redirectStatuses.indexOf(status) === -1) {
-      throw new RangeError('Invalid status code')
-    }
-
-    return new Response(null, {status: status, headers: {location: url}})
-  };
-
-  exports.DOMException = g.DOMException;
-  try {
-    new exports.DOMException();
-  } catch (err) {
-    exports.DOMException = function(message, name) {
-      this.message = message;
-      this.name = name;
-      var error = Error(message);
-      this.stack = error.stack;
-    };
-    exports.DOMException.prototype = Object.create(Error.prototype);
-    exports.DOMException.prototype.constructor = exports.DOMException;
-  }
-
-  function fetch(input, init) {
-    return new Promise(function(resolve, reject) {
-      var request = new Request(input, init);
-
-      if (request.signal && request.signal.aborted) {
-        return reject(new exports.DOMException('Aborted', 'AbortError'))
-      }
-
-      var xhr = new XMLHttpRequest();
-
-      function abortXhr() {
-        xhr.abort();
-      }
-
-      xhr.onload = function() {
-        var options = {
-          statusText: xhr.statusText,
-          headers: parseHeaders(xhr.getAllResponseHeaders() || '')
-        };
-        // This check if specifically for when a user fetches a file locally from the file system
-        // Only if the status is out of a normal range
-        if (request.url.indexOf('file://') === 0 && (xhr.status < 200 || xhr.status > 599)) {
-          options.status = 200;
-        } else {
-          options.status = xhr.status;
-        }
-        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
-        var body = 'response' in xhr ? xhr.response : xhr.responseText;
-        setTimeout(function() {
-          resolve(new Response(body, options));
-        }, 0);
-      };
-
-      xhr.onerror = function() {
-        setTimeout(function() {
-          reject(new TypeError('Network request failed'));
-        }, 0);
-      };
-
-      xhr.ontimeout = function() {
-        setTimeout(function() {
-          reject(new TypeError('Network request timed out'));
-        }, 0);
-      };
-
-      xhr.onabort = function() {
-        setTimeout(function() {
-          reject(new exports.DOMException('Aborted', 'AbortError'));
-        }, 0);
-      };
-
-      function fixUrl(url) {
-        try {
-          return url === '' && g.location.href ? g.location.href : url
-        } catch (e) {
-          return url
-        }
-      }
-
-      xhr.open(request.method, fixUrl(request.url), true);
-
-      if (request.credentials === 'include') {
-        xhr.withCredentials = true;
-      } else if (request.credentials === 'omit') {
-        xhr.withCredentials = false;
-      }
-
-      if ('responseType' in xhr) {
-        if (support.blob) {
-          xhr.responseType = 'blob';
-        } else if (
-          support.arrayBuffer
-        ) {
-          xhr.responseType = 'arraybuffer';
-        }
-      }
-
-      if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers || (g.Headers && init.headers instanceof g.Headers))) {
-        var names = [];
-        Object.getOwnPropertyNames(init.headers).forEach(function(name) {
-          names.push(normalizeName(name));
-          xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
-        });
-        request.headers.forEach(function(value, name) {
-          if (names.indexOf(name) === -1) {
-            xhr.setRequestHeader(name, value);
-          }
-        });
-      } else {
-        request.headers.forEach(function(value, name) {
-          xhr.setRequestHeader(name, value);
-        });
-      }
-
-      if (request.signal) {
-        request.signal.addEventListener('abort', abortXhr);
-
-        xhr.onreadystatechange = function() {
-          // DONE (success or failure)
-          if (xhr.readyState === 4) {
-            request.signal.removeEventListener('abort', abortXhr);
-          }
-        };
-      }
-
-      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
-    })
-  }
-
-  fetch.polyfill = true;
-
-  if (!g.fetch) {
-    g.fetch = fetch;
-    g.Headers = Headers;
-    g.Request = Request;
-    g.Response = Response;
-  }
-
-  exports.Headers = Headers;
-  exports.Request = Request;
-  exports.Response = Response;
-  exports.fetch = fetch;
-
-  return exports;
-
-})({});
-})(__globalThis__);
-// This is a ponyfill, so...
-__globalThis__.fetch.ponyfill = true;
-delete __globalThis__.fetch.polyfill;
-// Choose between native implementation (__global__) or custom implementation (__globalThis__)
-var ctx = __global__.fetch ? __global__ : __globalThis__;
-exports = ctx.fetch // To enable: import fetch from 'cross-fetch'
-exports["default"] = ctx.fetch // For TypeScript consumers without esModuleInterop.
-exports.fetch = ctx.fetch // To enable: import {fetch} from 'cross-fetch'
-exports.Headers = ctx.Headers
-exports.Request = ctx.Request
-exports.Response = ctx.Response
-module.exports = exports
-
-
-/***/ },
-
-/***/ 953
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const crossFetch = __webpack_require__(945);
-
-/**
- * Metadata header names
- * @enum {string} The enum value is the name of the associated header.
- * @readonly
- */
-const RequestMetadata = {
-  /** The ID of the project associated with this request */
-  ProjectId: 'X-Project-ID',
-  /** The ID of the project run associated with this request */
-  RunId: 'X-Run-ID'
-};
-
-/**
- * Metadata headers for requests
- * @type {Headers}
- */
-const metadata = new crossFetch.Headers();
-
-/**
- * Check if there is any metadata to apply.
- * @returns {boolean} true if `metadata` has contents, or false if it is empty.
- */
-const hasMetadata = () => {
-  /* global self */
-  const searchParams = typeof self !== 'undefined' && self && self.location && self.location.search && self.location.search.split(/[?&]/) || [];
-  if (!searchParams.includes('scratchMetadata=1')) {
-    // for now, disable this feature unless scratchMetadata=1
-    // TODO: remove this check once we're sure the feature works correctly in production
-    return false;
-  }
-  for (const _ of metadata) {
-    return true;
-  }
-  return false;
-};
-
-/**
- * Non-destructively merge any metadata state (if any) with the provided options object (if any).
- * If there is metadata state but no options object is provided, make a new object.
- * If there is no metadata state, return the provided options parameter without modification.
- * If there is metadata and an options object is provided, modify a copy and return it.
- * Headers in the provided options object may override headers generated from metadata state.
- * @param {RequestInit} [options] The initial request options. May be null or undefined.
- * @returns {RequestInit|undefined} the provided options parameter without modification, or a new options object.
- */
-const applyMetadata = options => {
-  if (hasMetadata()) {
-    const augmentedOptions = Object.assign({}, options);
-    augmentedOptions.headers = new crossFetch.Headers(metadata);
-    if (options && options.headers) {
-      // the Fetch spec says options.headers could be:
-      // "A Headers object, an object literal, or an array of two-item arrays to set request's headers."
-      // turn it into a Headers object to be sure of how to interact with it
-      const overrideHeaders = options.headers instanceof crossFetch.Headers ? options.headers : new crossFetch.Headers(options.headers);
-      for (const [name, value] of overrideHeaders.entries()) {
-        augmentedOptions.headers.set(name, value);
-      }
-    }
-    return augmentedOptions;
-  }
-  return options;
-};
-
-/**
- * Make a network request.
- * This is a wrapper for the global fetch method, adding some Scratch-specific functionality.
- * @param {RequestInfo|URL} resource The resource to fetch.
- * @param {RequestInit} options Optional object containing custom settings for this request.
- * @see {@link https://developer.mozilla.org/docs/Web/API/fetch} for more about the fetch API.
- * @returns {Promise<Response>} A promise for the response to the request.
- */
-const scratchFetch = (resource, options) => {
-  const augmentedOptions = applyMetadata(options);
-  return crossFetch(resource, augmentedOptions);
-};
-
-/**
- * Set the value of a named request metadata item.
- * Setting the value to `null` or `undefined` will NOT remove the item.
- * Use `unsetMetadata` for that.
- * @param {RequestMetadata} name The name of the metadata item to set.
- * @param {any} value The value to set (will be converted to a string).
- */
-const setMetadata = (name, value) => {
-  metadata.set(name, value);
-};
-
-/**
- * Remove a named request metadata item.
- * @param {RequestMetadata} name The name of the metadata item to remove.
- */
-const unsetMetadata = name => {
-  metadata.delete(name);
-};
-
-/**
- * Retrieve a named request metadata item.
- * Only for use in tests. At the time of writing, used in scratch-vm tests.
- * @param {RequestMetadata} name The name of the metadata item to retrieve.
- * @returns {any} value The value of the metadata item, or `undefined` if it was not found.
- */
-const getMetadata = name => metadata.get(name);
-module.exports = {
-  Headers: crossFetch.Headers,
-  RequestMetadata,
-  applyMetadata,
-  scratchFetch,
-  setMetadata,
-  unsetMetadata,
-  getMetadata
-};
-
 /***/ }
 
 /******/ 	});
@@ -3686,7 +2876,7 @@ module.exports = {
 /******/ 		// This function allow to reference async chunks
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "chunks/" + "fetch-worker" + "." + "56da39b0f4bad6747138" + ".js";
+/******/ 			return "chunks/" + "fetch-worker" + "." + "7afe4ade866d6f6a3cb3" + ".js";
 /******/ 		};
 /******/ 	})();
 /******/ 	
@@ -3745,6 +2935,20 @@ __webpack_require__.d(__webpack_exports__, {
   ScratchStorage: () => (/* reexport */ ScratchStorage)
 });
 
+// NAMESPACE OBJECT: ./src/scratchFetch.ts
+var scratchFetch_namespaceObject = {};
+__webpack_require__.r(scratchFetch_namespaceObject);
+__webpack_require__.d(scratchFetch_namespaceObject, {
+  Headers: () => (Headers),
+  RequestMetadata: () => (RequestMetadata),
+  applyMetadata: () => (applyMetadata),
+  getMetadata: () => (getMetadata),
+  hasMetadata: () => (hasMetadata),
+  scratchFetch: () => (scratchFetch),
+  setMetadata: () => (setMetadata),
+  unsetMetadata: () => (unsetMetadata)
+});
+
 // EXTERNAL MODULE: ./node_modules/minilog/lib/web/index.js
 var web = __webpack_require__(557);
 var web_default = /*#__PURE__*/__webpack_require__.n(web);
@@ -4135,9 +3339,295 @@ class BuiltinHelper extends Helper {
     return Promise.resolve(this.get(assetId));
   }
 }
-// EXTERNAL MODULE: ./src/scratchFetch.js
-var scratchFetch = __webpack_require__(953);
-var scratchFetch_default = /*#__PURE__*/__webpack_require__.n(scratchFetch);
+;// ./node_modules/@scratch/task-herder/dist/task-herder.js
+const CancelReason = {
+	QueueCostLimitExceeded: "Queue cost limit exceeded",
+	Aborted: "Task aborted",
+	Cancel: "Task cancelled",
+	TaskTooExpensive: "Task cost exceeds maximum bucket size"
+};
+function PromiseWithResolvers() {
+	let e, t;
+	return {
+		promise: new Promise((n, r) => {
+			e = n, t = r;
+		}),
+		resolve: e,
+		reject: t
+	};
+}
+var TaskRecord = class {
+	cost;
+	promise;
+	run;
+	cancel;
+	constructor(e, n = {}) {
+		this.cost = n.cost ?? 1;
+		let { promise: r, resolve: i, reject: a } = PromiseWithResolvers();
+		this.promise = r, this.cancel = (e) => {
+			a(e);
+		}, this.run = async () => {
+			try {
+				i(await e());
+			} catch (e) {
+				a(e);
+			}
+		};
+	}
+}, TaskQueue = class {
+	burstLimit;
+	sustainRate;
+	queueCostLimit;
+	concurrencyLimit;
+	tokenCount;
+	runningTasks = 0;
+	pendingTaskRecords = [];
+	lastRefillTime = Date.now();
+	onTaskAdded = PromiseWithResolvers().resolve;
+	onTaskFinished = PromiseWithResolvers().resolve;
+	constructor(e) {
+		this.burstLimit = e.burstLimit, this.sustainRate = e.sustainRate, this.tokenCount = e.startingTokens ?? e.burstLimit, this.queueCostLimit = e.queueCostLimit ?? Infinity, this.concurrencyLimit = e.concurrency ?? 1, this.runTasks();
+	}
+	get length() {
+		return this.pendingTaskRecords.length;
+	}
+	get options() {
+		return {
+			burstLimit: this.burstLimit,
+			sustainRate: this.sustainRate,
+			startingTokens: this.tokenCount,
+			queueCostLimit: this.queueCostLimit,
+			concurrency: this.concurrencyLimit
+		};
+	}
+	do(t, r = {}) {
+		let i = new TaskRecord(t, r);
+		return i.cost > this.burstLimit ? Promise.reject(Error(CancelReason.TaskTooExpensive)) : this.queueCostLimit < Infinity && this.pendingTaskRecords.reduce((e, t) => e + t.cost, i.cost) > this.queueCostLimit ? Promise.reject(Error(CancelReason.QueueCostLimitExceeded)) : (this.pendingTaskRecords.push(i), r.signal?.addEventListener("abort", () => {
+			this.cancel(i.promise, Error(CancelReason.Aborted));
+		}), this.onTaskAdded(), i.promise);
+	}
+	cancel(t, n) {
+		let r = this.pendingTaskRecords.findIndex((e) => e.promise === t);
+		if (r !== -1) {
+			let [t] = this.pendingTaskRecords.splice(r, 1);
+			return t.cancel(n ?? Error(CancelReason.Cancel)), !0;
+		}
+		return !1;
+	}
+	cancelAll(t) {
+		let n = this.pendingTaskRecords;
+		return this.pendingTaskRecords = [], t ??= Error(CancelReason.Cancel), n.forEach((e) => {
+			e.cancel(t);
+		}), n.length;
+	}
+	refillAndSpend(e) {
+		return this.refill(), this.spend(e);
+	}
+	refill() {
+		let e = Date.now(), t = e - this.lastRefillTime;
+		if (t <= 0) return;
+		this.lastRefillTime = e;
+		let n = t / 1e3 * this.sustainRate;
+		this.tokenCount = Math.min(this.burstLimit, this.tokenCount + n);
+	}
+	spend(e) {
+		return this.tokenCount >= e ? (this.tokenCount -= e, !0) : !1;
+	}
+	async runTasks() {
+		for (;;) {
+			let n = this.pendingTaskRecords.shift();
+			if (!n) {
+				let { promise: e, resolve: n } = PromiseWithResolvers();
+				this.onTaskAdded = n, await e;
+				continue;
+			}
+			if (n.cost > this.burstLimit) {
+				n.cancel(Error(CancelReason.TaskTooExpensive));
+				continue;
+			}
+			if (this.refillAndSpend(n.cost)) {
+				if (this.runningTasks >= this.concurrencyLimit) {
+					let { promise: e, resolve: n } = PromiseWithResolvers();
+					this.onTaskFinished = n, await e;
+				}
+				this.runTask(n);
+			} else {
+				this.pendingTaskRecords.unshift(n);
+				let e = Math.max(n.cost - this.tokenCount, 0), t = Math.ceil(1e3 * e / this.sustainRate);
+				await new Promise((e) => setTimeout(e, t));
+			}
+		}
+	}
+	async runTask(e) {
+		this.runningTasks++;
+		try {
+			await e.run();
+		} finally {
+			this.runningTasks--, this.onTaskFinished();
+		}
+	}
+}, QueueManager = class {
+	queues;
+	defaultOptions;
+	constructor(e, t) {
+		this.queues = new Map(t), this.defaultOptions = e;
+	}
+	create(e, t = {}) {
+		let n = new TaskQueue({
+			...this.defaultOptions,
+			...t
+		});
+		return this.queues.set(e, n), n;
+	}
+	get(e) {
+		return this.queues.get(e);
+	}
+	getOrCreate(e, t = {}) {
+		return this.get(e) ?? this.create(e, t);
+	}
+	options() {
+		return { ...this.defaultOptions };
+	}
+};
+
+
+;// ./src/HostQueues.ts
+
+/**
+ * @summary A set of generous limits, for things like downloading assets from CDN.
+ * @description
+ * In practice, these limits seem to lead to slightly better performance than no limits at all, mostly due to the
+ * concurrency limit. For example, on my development computer & my relatively fast residential connection, a
+ * concurrency limit of 4 loads a particular test project in 21 seconds, as opposed to 25 seconds when I bypass the
+ * queue and call `fetch` directly. In that test, my setup downloads about 50 assets per second, so this set of options
+ * only affects concurrency and doesn't actually throttle the downloads. Limiting concurrency also fixes the issue
+ * where very large projects (thousands of assets) can lead to browser failures like `net::ERR_INSUFFICIENT_RESOURCES`.
+ * The exact concurrency limit doesn't seem to matter much since the browser limits parallel connections itself. It
+ * just needs to be high enough to avoid bubbles in the download pipeline and low enough to avoid resource exhaustion.
+ * @see {@link https://github.com/scratchfoundation/scratch-gui/issues/7111}
+ */
+const AssetQueueOptions = {
+  burstLimit: 64,
+  sustainRate: 64,
+  // WARNING: asset download concurrency >=5 can lead to corrupted buffers on Chrome (December 2025, Chrome 142.0)
+  // when using Scratch's bitmap load pipeline. Marking the canvas context as `{willReadFrequently: true}` seems to
+  // eliminate that issue, so maybe the problem is related to hardware acceleration.
+  concurrency: 64
+};
+/**
+ * Central registry of per-host queues.
+ * Uses strict limits by default. Override these strict limits as needed for specific hosts.
+ */
+const hostQueueManager = new QueueManager({
+  burstLimit: 5,
+  sustainRate: 1,
+  concurrency: 1
+});
+;// ./src/scratchFetch.ts
+
+const Headers = globalThis.Headers;
+/**
+ * Metadata header names.
+ * The enum value is the name of the associated header.
+ */
+var RequestMetadata;
+(function (RequestMetadata) {
+  /** The ID of the project associated with this request */
+  RequestMetadata["ProjectId"] = "X-Project-ID";
+  /** The ID of the project run associated with this request */
+  RequestMetadata["RunId"] = "X-Run-ID";
+})(RequestMetadata || (RequestMetadata = {}));
+/**
+ * Metadata headers for requests.
+ */
+const metadata = new Headers();
+/**
+ * Check if there is any metadata to apply.
+ * @returns {boolean} true if `metadata` has contents, or false if it is empty.
+ */
+const hasMetadata = () => {
+  const searchParams = typeof self !== 'undefined' && self && self.location && self.location.search && self.location.search.split(/[?&]/) || [];
+  if (!searchParams.includes('scratchMetadata=1')) {
+    // for now, disable this feature unless scratchMetadata=1
+    // TODO: remove this check once we're sure the feature works correctly in production
+    return false;
+  }
+  for (const _ of metadata) {
+    return true;
+  }
+  return false;
+};
+/**
+ * Non-destructively merge any metadata state (if any) with the provided options object (if any).
+ * If there is metadata state but no options object is provided, make a new object.
+ * If there is no metadata state, return the provided options parameter without modification.
+ * If there is metadata and an options object is provided, modify a copy and return it.
+ * Headers in the provided options object may override headers generated from metadata state.
+ * @param {RequestInit} [options] The initial request options. May be null or undefined.
+ * @returns {RequestInit|undefined} the provided options parameter without modification, or a new options object.
+ */
+const applyMetadata = options => {
+  if (hasMetadata()) {
+    const augmentedOptions = Object.assign({}, options);
+    augmentedOptions.headers = new Headers(metadata);
+    if (options && options.headers) {
+      // the Fetch spec says options.headers could be:
+      // "A Headers object, an object literal, or an array of two-item arrays to set request's headers."
+      // turn it into a Headers object to be sure of how to interact with it
+      const overrideHeaders = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      for (const [name, value] of overrideHeaders.entries()) {
+        augmentedOptions.headers.set(name, value);
+      }
+    }
+    return augmentedOptions;
+  }
+  return options;
+};
+/**
+ * Make a network request.
+ * This is a wrapper for the global fetch method, adding some Scratch-specific functionality.
+ * @param {RequestInfo|URL} resource The resource to fetch.
+ * @param {RequestInit} [requestOptions] Optional object containing custom settings for this request.
+ * @param {ScratchFetchOptions} [scratchOptions] Optional Scratch-specific settings for this request.
+ * @see {@link https://developer.mozilla.org/docs/Web/API/fetch} for more about the fetch API.
+ * @returns {Promise<Response>} A promise for the response to the request.
+ */
+const scratchFetch = (resource, requestOptions, scratchOptions) => {
+  requestOptions = applyMetadata(requestOptions);
+  let queueName = scratchOptions === null || scratchOptions === void 0 ? void 0 : scratchOptions.queueName;
+  if (!queueName) {
+    // Normalize resource to a Request object. The `fetch` call will do this anyway, so it's not much extra work,
+    // but it guarantees availability of the URL for queue naming.
+    resource = new Request(resource, requestOptions);
+    queueName = new URL(resource.url).hostname;
+  }
+  const queue = hostQueueManager.getOrCreate(queueName, scratchOptions === null || scratchOptions === void 0 ? void 0 : scratchOptions.queueOptions);
+  return queue.do(() => fetch(resource, requestOptions));
+};
+/**
+ * Set the value of a named request metadata item.
+ * Setting the value to `null` or `undefined` will NOT remove the item.
+ * Use `unsetMetadata` for that.
+ * @param {RequestMetadata} name The name of the metadata item to set.
+ * @param {any} value The value to set (will be converted to a string).
+ */
+const setMetadata = (name, value) => {
+  metadata.set(name, value);
+};
+/**
+ * Remove a named request metadata item.
+ * @param {RequestMetadata} name The name of the metadata item to remove.
+ */
+const unsetMetadata = name => {
+  metadata.delete(name);
+};
+/**
+ * Retrieve a named request metadata item.
+ * Only for use in tests. At the time of writing, used in scratch-vm tests.
+ * @param {RequestMetadata} name The name of the metadata item to retrieve.
+ * @returns {string|null} The value of the metadata item, or `null` if it was not found.
+ */
+const getMetadata = name => metadata.get(name);
 ;// ./src/FetchWorkerTool.ts
 const _excluded = ["url"];
 function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
@@ -4238,14 +3728,14 @@ class PrivateFetchWorkerTool {
     return new Promise((resolve, reject) => {
       // TODO: Use a Scratch standard ID generator ...
       const id = Math.random().toString(16).substring(2);
-      const augmentedOptions = (0,scratchFetch.applyMetadata)(Object.assign({
+      const augmentedOptions = applyMetadata(Object.assign({
         method: 'GET'
       }, options));
       // the Fetch spec says options.headers could be:
       // "A Headers object, an object literal, or an array of two-item arrays to set request's headers."
       // structured clone (postMessage) doesn't support Headers objects
       // so turn it into an array of two-item arrays to make it to the worker intact
-      if (augmentedOptions && augmentedOptions.headers instanceof scratchFetch.Headers) {
+      if (augmentedOptions && augmentedOptions.headers instanceof Headers) {
         augmentedOptions.headers = Array.from(augmentedOptions.headers.entries());
       }
       worker.postMessage({
@@ -4337,6 +3827,7 @@ const FetchTool_excluded = ["url"],
 function FetchTool_objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = FetchTool_objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
 function FetchTool_objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
 
+
 /**
  * @typedef {Request & {withCredentials: boolean}} ScratchSendRequest
  */
@@ -4362,9 +3853,11 @@ class FetchTool {
         url
       } = _ref,
       options = FetchTool_objectWithoutProperties(_ref, FetchTool_excluded);
-    return (0,scratchFetch.scratchFetch)(url, Object.assign({
+    return scratchFetch(url, Object.assign({
       method: 'GET'
-    }, options)).then(result => {
+    }, options), {
+      queueOptions: AssetQueueOptions
+    }).then(result => {
       if (result.ok) return result.arrayBuffer().then(b => new Uint8Array(b));
       if (result.status === 404) return null;
       return Promise.reject(result.status); // TODO: we should throw a proper error
@@ -4389,9 +3882,11 @@ class FetchTool {
         withCredentials = false
       } = _ref2,
       options = FetchTool_objectWithoutProperties(_ref2, _excluded2);
-    return (0,scratchFetch.scratchFetch)(url, Object.assign({
+    return scratchFetch(url, Object.assign({
       credentials: withCredentials ? 'include' : 'omit'
-    }, options)).then(response => {
+    }, options), {
+      queueOptions: AssetQueueOptions
+    }).then(response => {
       if (response.ok) return response.text();
       return Promise.reject(response.status);
     });
@@ -4713,7 +4208,7 @@ class ScratchStorage {
    * @returns {module} the scratchFetch module, with properties for `scratchFetch`, `setMetadata`, etc.
    */
   get scratchFetch() {
-    return (scratchFetch_default());
+    return scratchFetch_namespaceObject;
   }
   /**
    * @deprecated Please use the `Asset` member of a storage instance instead.