@loaders.gl/core 5.0.0-alpha.7 → 5.0.0-alpha.9

package/dist/index.cjs

@@ -1181,13 +1181,17 @@ function validateWorkerVersion(worker, coreVersion = VERSION2) {
 
 // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
 function canParseWithWorker(loader, options) {
-  var _a;
+  var _a, _b, _c;
+  if ((_b = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.some(
+    (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
+  ))
+    return false;
   const workerOptions = getWorkerOptions(options);
   const nodeWorkers = workerOptions._nodeWorkers;
   if (!isBrowser2 && !nodeWorkers) {
     return false;
   }
-  if (loader.id === "las" && (((_a = options == null ? void 0 : options.las) == null ? void 0 : _a.shape) ?? "arrow-table") === "arrow-table") {
+  if (loader.id === "las" && (((_c = options == null ? void 0 : options.las) == null ? void 0 : _c.shape) ?? "arrow-table") === "arrow-table") {
     return false;
   }
   if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
@@ -1278,7 +1282,12 @@ function callParseOnMainThread(parseOnMainThread, input, options, context) {
   return parseOnMainThread(input, void 0, options, context);
 }
 function getWorkerOptions(options = {}, loader) {
-  const serializedOptions = JSON.parse(JSON.stringify(options));
+  const serializedOptions = JSON.parse(
+    JSON.stringify({
+      ...options,
+      ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
+    })
+  );
   const workerOptions = {
     ...serializedOptions.core,
     ...serializedOptions
@@ -1353,6 +1362,19 @@ function concatenateArrayBuffersFromArray(sources) {
   return result.buffer;
 }
 
+// ../loader-utils/src/lib/binary-utils/encode-array-buffer-to-base64.ts
+function encodeArrayBufferToBase64(arrayBuffer) {
+  const bytes = new Uint8Array(arrayBuffer);
+  const encodedChunks = [];
+  const chunkByteLength = 3 * 4096;
+  for (let byteOffset = 0; byteOffset < bytes.length; byteOffset += chunkByteLength) {
+    encodedChunks.push(
+      btoa(String.fromCharCode(...bytes.subarray(byteOffset, byteOffset + chunkByteLength)))
+    );
+  }
+  return encodedChunks.join("");
+}
+
 // ../loader-utils/src/lib/iterators/text-iterators.ts
 async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
   const textDecoder = new TextDecoder(void 0, options);
@@ -1487,6 +1509,7 @@ var RequestScheduler = class {
   /** Tracks the number of active requests and prioritizes/cancels queued requests. */
   requestQueue = [];
   requestMap = /* @__PURE__ */ new Map();
+  /** Pending arrival debounce or next-tick refill; only new arrivals replace this timer. */
   updateTimer = null;
   constructor(props = {}) {
     this.props = { ...DEFAULT_PROPS2, ...props };
@@ -1554,20 +1577,27 @@ var RequestScheduler = class {
         isDone = true;
         this.requestMap.delete(handle);
         this.activeRequestCount--;
-        this._issueNewRequests();
+        this.scheduleRefill();
       }
     };
     this.activeRequestCount++;
     return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
   }
-  /** We check requests asynchronously, to prevent multiple updates */
+  /** Refills freed slots on the next tick while preserving any pending arrival debounce. */
+  scheduleRefill() {
+    if (this.updateTimer !== null) {
+      return;
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), 0);
+  }
+  /** Restarts the quiet period when a new request enters the queue. */
   _issueNewRequests() {
     if (this.updateTimer !== null) {
       clearTimeout(this.updateTimer);
     }
     this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
   }
-  /** Refresh all requests  */
+  /** Clears timer ownership before updating priorities and dispatching queued requests. */
   _issueNewRequestsAsync() {
     if (this.updateTimer !== null) {
       clearTimeout(this.updateTimer);
@@ -1609,25 +1639,110 @@ var RequestScheduler = class {
   }
 };
 
+// ../loader-utils/src/lib/request-utils/authentication.ts
+function resolveCredentials(credentials, authentications = []) {
+  if (credentials.every(isAuthentication)) return credentials;
+  return credentials.map((credential, index) => {
+    if (isAuthentication(credential)) return credential;
+    const AuthenticationClass = authentications.find(
+      (authentication2) => authentication2.type === (credential == null ? void 0 : credential.type)
+    );
+    if (!AuthenticationClass) {
+      throw new Error(`No authentication class registered for credential at index ${index}.`);
+    }
+    let authentication;
+    try {
+      authentication = new AuthenticationClass(credential);
+    } catch {
+      throw new Error(`Invalid authentication configuration at index ${index}.`);
+    }
+    if (!isAuthentication(authentication)) {
+      throw new Error(`Authentication class returned an invalid credential at index ${index}.`);
+    }
+    return authentication;
+  });
+}
+function resolveAuthenticationOptions(options) {
+  var _a, _b;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length)) return options;
+  const credentials = resolveCredentials(options.core.credentials, options.core.authentications);
+  if (credentials === options.core.credentials) return options;
+  return { ...options, core: { ...options.core, credentials } };
+}
+async function resolveLoaderAuthenticationOptions(loader, url, options) {
+  var _a, _b, _c, _d;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) || options.core.credentials.every(isAuthentication)) {
+    return options;
+  }
+  const contributions = await ((_c = loader == null ? void 0 : loader.getAuthentications) == null ? void 0 : _c.call(loader, url, options));
+  if (!(contributions == null ? void 0 : contributions.length)) return resolveAuthenticationOptions(options);
+  return resolveAuthenticationOptions({
+    ...options,
+    core: {
+      ...options.core,
+      authentications: [...((_d = options.core) == null ? void 0 : _d.authentications) || [], ...contributions]
+    }
+  });
+}
+function isAuthentication(credential) {
+  if (!credential || typeof credential !== "object") return false;
+  if (typeof credential.id !== "string" || !Array.isArray(credential.origins)) return false;
+  if (credential.type === "request") return typeof credential.authenticate === "function";
+  return (credential.type === "header" || credential.type === "query-parameter") && typeof credential.name === "string" && (typeof credential.token === "string" || typeof credential.token === "function") && Array.isArray(credential.refreshStatusCodes);
+}
+
 // ../loader-utils/src/lib/request-utils/request-credentials.ts
 var AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
 var refreshPromises = /* @__PURE__ */ new WeakMap();
 function createAuthenticatedFetch(options) {
-  const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
-  if (!options.credentials.length) return baseFetch;
-  const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
-  if (existingMetadata === options.credentials) return baseFetch;
+  const suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+  const credentialResolutions = new Map(existingMetadata == null ? void 0 : existingMetadata.credentialResolutions);
+  const resolvedCredentials = resolveCredentials(
+    options.credentials.map((credential) => credentialResolutions.get(credential) || credential),
+    options.authentications
+  );
+  options.credentials.forEach((credential, index) => {
+    credentialResolutions.set(credential, resolvedCredentials[index]);
+  });
+  if (!options.fetchOptions && (!resolvedCredentials.length || (existingMetadata == null ? void 0 : existingMetadata.credentials.length) === resolvedCredentials.length && resolvedCredentials.every(
+    (credential, index) => credential === existingMetadata.credentials[index]
+  )))
+    return suppliedFetch;
+  const baseFetch = (existingMetadata == null ? void 0 : existingMetadata.fetch) || suppliedFetch;
+  const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+  const fetchOptions = mergeFetchOptions(
+    (existingMetadata == null ? void 0 : existingMetadata.fetchOptions) || {},
+    options.fetchOptions
+  );
+  const tokenCredentials = credentials.filter(
+    (credential) => credential.type !== "request"
+  );
+  const requestCredentials = credentials.filter(
+    (credential) => credential.type === "request"
+  );
+  for (const credential of requestCredentials) normalizeRequestOrigins(credential.origins);
   const authenticatedFetch = async (url, requestOptions = {}) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
+    requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError3();
+    if (!credentials.length) return baseFetch(url, requestOptions);
     const resolvedURL = parseHTTPURL(url);
-    if (!resolvedURL) return baseFetch(url, requestOptions);
-    const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
-    const response = await baseFetch(authorization.url, authorization.options);
+    const authorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials) : { url, options: requestOptions, credentials: [] };
+    const signedRequest = await authenticateRequest(authorization, requestCredentials, "request");
+    const response = await baseFetch(signedRequest.url, signedRequest.options);
     const refreshableCredentials = authorization.credentials.filter(
       ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
     );
-    if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
-    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError3();
+    const shouldRetrySignature = signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature || !isReplayableRequest(requestOptions) || !isReplayableRequest(signedRequest.options))
+      return response;
+    if ((_b = requestOptions.signal) == null ? void 0 : _b.aborted) throw createAbortError3();
     const refreshedTokens = /* @__PURE__ */ new Map();
     await Promise.all(
       refreshableCredentials.map(async ({ credential }) => {
@@ -1635,24 +1750,95 @@ function createAuthenticatedFetch(options) {
         if (token) refreshedTokens.set(credential, token);
       })
     );
-    if (!refreshedTokens.size) return response;
-    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    if (!refreshedTokens.size && !shouldRetrySignature) return response;
+    await ((_c = response.body) == null ? void 0 : _c.cancel().catch(() => {
     }));
-    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError3();
-    const replayAuthorization = await authorizeRequest(
+    if ((_d = requestOptions.signal) == null ? void 0 : _d.aborted) throw createAbortError3();
+    const replayAuthorization = resolvedURL ? await authorizeRequest(
       resolvedURL,
       requestOptions,
-      options.credentials,
+      tokenCredentials,
       refreshedTokens,
       authorization.credentials
+    ) : { url, options: requestOptions };
+    const replayRequest = await authenticateRequest(
+      replayAuthorization,
+      requestCredentials,
+      "retry",
+      response
     );
-    return baseFetch(replayAuthorization.url, replayAuthorization.options);
+    return baseFetch(replayRequest.url, replayRequest.options);
   };
   Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
-    value: options.credentials
+    value: {
+      fetch: baseFetch,
+      credentials,
+      credentialResolutions,
+      fetchOptions
+    }
   });
   return authenticatedFetch;
 }
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
+async function authenticateRequest(request, credentials, reason, response) {
+  const appliedCredentials = [];
+  const signal = request.options.signal;
+  for (const credential of credentials) {
+    const origin = getRequestOrigin(request.url);
+    if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin)) continue;
+    if (signal == null ? void 0 : signal.aborted) throw createAbortError3();
+    const authenticatedRequest = await credential.authenticate({
+      url: request.url,
+      options: { ...request.options, headers: new Headers(request.options.headers) },
+      reason,
+      response: response ? { status: response.status, headers: new Headers(response.headers) } : void 0
+    });
+    if (!authenticatedRequest || typeof authenticatedRequest.url !== "string" || !authenticatedRequest.options || typeof authenticatedRequest.options !== "object") {
+      throw new Error("Authentication callback returned an invalid request.");
+    }
+    request = {
+      url: authenticatedRequest.url,
+      options: { ...authenticatedRequest.options, ...signal ? { signal } : {} }
+    };
+    appliedCredentials.push(credential);
+  }
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError3();
+  return { ...request, credentials: appliedCredentials };
+}
+function getRequestOrigin(url) {
+  try {
+    const parsedURL = new URL(url);
+    if (!parsedURL.host || parsedURL.username || parsedURL.password) return null;
+    return parsedURL.origin !== "null" ? parsedURL.origin : `${parsedURL.protocol}//${parsedURL.host}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeRequestOrigins(origins) {
+  if (!origins.length)
+    throw new Error("Request authentication requires at least one exact origin.");
+  return origins.map((origin) => {
+    const resolvedOrigin = getRequestOrigin(origin);
+    let url;
+    try {
+      url = new URL(origin);
+    } catch {
+      throw new Error("Invalid request authentication origin.");
+    }
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
+  });
+}
 async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
   const url = new URL(sourceURL);
   const headers = new Headers(requestOptions.headers);
@@ -2222,19 +2408,11 @@ async function getInitialDataUrl(resource) {
   }
   if (resource instanceof ArrayBuffer) {
     const slice = resource.slice(0, INITIAL_DATA_LENGTH);
-    const base64 = arrayBufferToBase64(slice);
+    const base64 = encodeArrayBufferToBase64(slice);
     return `data:base64,${base64}`;
   }
   return null;
 }
-function arrayBufferToBase64(buffer) {
-  let binary = "";
-  const bytes = new Uint8Array(buffer);
-  for (let i = 0; i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
 
 // dist/lib/fetch/fetch-file.js
 function isNodePath(url) {
@@ -2349,6 +2527,7 @@ var ConsoleLog = class {
 
 // dist/lib/loader-utils/option-defaults.js
 var DEFAULT_LOADER_OPTIONS = {
+  searchParams: void 0,
   core: {
     baseUrl: void 0,
     // baseUrl
@@ -2455,6 +2634,27 @@ var CORE_LOADER_OPTION_KEYS = [
   "metadata",
   "transforms"
 ];
+function applySearchParamsToUrl(url, options) {
+  const searchParams = options == null ? void 0 : options.searchParams;
+  if (!searchParams || Object.keys(searchParams).length === 0 || /^(?:data|blob):/i.test(url)) {
+    return url;
+  }
+  const hashIndex = url.indexOf("#");
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+  const urlWithoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  const queryIndex = urlWithoutHash.indexOf("?");
+  const path = queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
+  const query = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : "";
+  const existingSearchParams = new URLSearchParams(query);
+  const appendedSearchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(searchParams)) {
+    if (!existingSearchParams.has(key)) {
+      appendedSearchParams.set(key, String(value));
+    }
+  }
+  const serializedAppendedSearchParams = appendedSearchParams.toString();
+  return `${path}${queryIndex >= 0 ? `?${query}` : ""}${serializedAppendedSearchParams ? `${queryIndex >= 0 ? "&" : "?"}${serializedAppendedSearchParams}` : ""}${hash}`;
+}
 function getGlobalLoaderState() {
   globalThis.loaders = globalThis.loaders || {};
   const { loaders } = globalThis;
@@ -3211,7 +3411,7 @@ function getIterableFromData(data) {
 
 // dist/lib/loader-utils/get-fetch-function.js
 function getFetchFunction(options, context) {
-  var _a, _b;
+  var _a, _b, _c;
   const globalOptions = getGlobalLoaderOptions();
   const loaderOptions = options || globalOptions;
   const fetchOption = loaderOptions.fetch ?? ((_a = loaderOptions.core) == null ? void 0 : _a.fetch);
@@ -3219,8 +3419,7 @@ function getFetchFunction(options, context) {
   if (typeof fetchOption === "function") {
     fetchFunction = fetchOption;
   } else if (isObject(fetchOption)) {
-    const baseFetch = (context == null ? void 0 : context.fetch) || fetchFile;
-    fetchFunction = (url, requestOptions) => baseFetch(url, mergeFetchOptions(fetchOption, requestOptions));
+    fetchFunction = (context == null ? void 0 : context.fetch) || fetchFile;
   } else if (context == null ? void 0 : context.fetch) {
     fetchFunction = context.fetch;
   } else {
@@ -3228,18 +3427,11 @@ function getFetchFunction(options, context) {
   }
   return createAuthenticatedFetch({
     fetch: fetchFunction,
-    credentials: ((_b = loaderOptions.core) == null ? void 0 : _b.credentials) || []
+    credentials: ((_b = loaderOptions.core) == null ? void 0 : _b.credentials) || [],
+    authentications: (_c = loaderOptions.core) == null ? void 0 : _c.authentications,
+    fetchOptions: isObject(fetchOption) ? fetchOption : void 0
   });
 }
-function mergeFetchOptions(defaultOptions, requestOptions) {
-  const options = { ...defaultOptions, ...requestOptions };
-  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
-    const headers = new Headers(defaultOptions.headers);
-    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
-    options.headers = headers;
-  }
-  return options;
-}
 
 // dist/lib/api/load-loader.js
 var loaderImplementationPromises = /* @__PURE__ */ new Map();
@@ -3340,6 +3532,7 @@ async function importLoaderImplementation(implementationSpecifier, loaderId) {
 
 // dist/lib/api/parse-file.js
 async function parseFile(file, loaders, options, context) {
+  var _a, _b;
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
@@ -3356,7 +3549,9 @@ async function parseFile(file, loaders, options, context) {
   if (isSourceLoader(loader)) {
     throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`);
   }
-  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const authenticationLoader = !loader.getAuthentications && ((_b = (_a = normalizedOptions.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, normalizedOptions, url || (context == null ? void 0 : context.url)) : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(authenticationLoader, url, normalizedOptions);
   context = getLoaderContext(
     // @ts-expect-error candidateLoaders may be a single forced loader
     { url, _parse: parse, loaders: candidateLoaders },
@@ -3469,6 +3664,7 @@ function makeBatchFromTable(table) {
 
 // dist/lib/api/parse-in-batches.js
 async function parseInBatches(data, loaders, options, context) {
+  var _a, _b;
   const loaderArray = Array.isArray(loaders) ? loaders : void 0;
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
@@ -3482,7 +3678,9 @@ async function parseInBatches(data, loaders, options, context) {
   if (!loader) {
     return [];
   }
-  const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+  const normalizedOptions = normalizeOptions(options, loader, loaderArray, url);
+  const authenticationLoader = !loader.getAuthentications && ((_b = (_a = normalizedOptions.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, normalizedOptions, url || (context == null ? void 0 : context.url)) : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(authenticationLoader, url || "", normalizedOptions);
   context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, strictOptions, context || null);
   const loaderWithParser = await getLoaderImplementation(loader, strictOptions, context.url);
   return await parseWithLoaderInBatches(loader, loaderWithParser, data, strictOptions, context);
@@ -3562,17 +3760,24 @@ function loadInBatches(files, loaders, options, context) {
   } else {
     loadersArray = loaders;
   }
-  const fetch2 = getFetchFunction(options || {});
   if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+    return loadOneFileInBatches(files, loadersArray, options || {});
   }
-  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
+  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}));
   return promises;
 }
-async function loadOneFileInBatches(file, loaders, options, fetch2) {
+async function loadOneFileInBatches(file, loaders, options) {
+  var _a, _b;
   if (typeof file === "string") {
     const url = file;
-    const response = await fetch2(url);
+    const loader = await selectLoader(url, loaders, {
+      ...options,
+      core: { ...options.core, nothrow: true }
+    });
+    const authenticationLoader = loader && !loader.getAuthentications && ((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, options, url) : loader;
+    options = await resolveLoaderAuthenticationOptions(authenticationLoader, url, options);
+    const fetch2 = getFetchFunction(options);
+    const response = await fetch2(applySearchParamsToUrl(url, options));
     return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
   }
   return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
@@ -3591,8 +3796,10 @@ async function load(url, loaders, options, context) {
     resolvedLoaders = loaders;
     resolvedOptions = options;
   }
+  resolvedOptions ||= getGlobalLoaderOptions();
   if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
     const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
+    resolvedOptions = await resolveLoaderAuthenticationOptions(resolvedLoaders.getAuthentications ? resolvedLoaders : sourceLoader, typeof url === "string" ? url : "", resolvedOptions || {});
     const runtimeCoreApi = {
       fetchFile,
       parse,
@@ -3606,6 +3813,7 @@ async function load(url, loaders, options, context) {
   }
   if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && isSourceLoader(resolvedLoaders[0])) {
     const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
+    resolvedOptions = await resolveLoaderAuthenticationOptions(resolvedLoaders[0].getAuthentications ? resolvedLoaders[0] : sourceLoader, typeof url === "string" ? url : "", resolvedOptions || {});
     const runtimeCoreApi = {
       fetchFile,
       parse,
@@ -3624,6 +3832,7 @@ async function load(url, loaders, options, context) {
     });
     if (selectedLoader && isSourceLoader(selectedLoader)) {
       const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(selectedLoader.getAuthentications ? selectedLoader : sourceLoader, typeof url === "string" ? url : "", resolvedOptions || {});
       return sourceLoader.createDataSource(url, resolvedOptions || {}, {
         fetchFile,
         parse,
@@ -3636,15 +3845,20 @@ async function load(url, loaders, options, context) {
     }
     if (selectedLoader && typeof url === "string") {
       const loaderImplementation = await getLoaderImplementation(selectedLoader, resolvedOptions, url);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(selectedLoader.getAuthentications ? selectedLoader : loaderImplementation, url, resolvedOptions || {});
       const parseUrl = loaderImplementation.parseUrl;
-      if (parseUrl)
-        return await parseUrl(url, resolvedOptions, context);
+      if (parseUrl) {
+        const requestUrl = applySearchParamsToUrl(url, resolvedOptions);
+        return await parseUrl(requestUrl, resolvedOptions, context);
+      }
     }
   }
+  if (resolvedOptions)
+    resolvedOptions = resolveAuthenticationOptions(resolvedOptions);
   const fetch2 = getFetchFunction(resolvedOptions);
   let data = url;
   if (typeof url === "string") {
-    data = await fetch2(url);
+    data = await fetch2(applySearchParamsToUrl(url, resolvedOptions));
   }
   if (isBlob(url)) {
     data = await fetch2(url);
@@ -3727,6 +3941,7 @@ function getLoadersFromContext(loaders, context) {
 
 // dist/lib/api/parse.js
 async function parse(data, loaders, options, context) {
+  var _a, _b;
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
@@ -3744,7 +3959,9 @@ async function parse(data, loaders, options, context) {
   if (isSourceLoader(loader)) {
     throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`);
   }
-  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const authenticationLoader = !loader.getAuthentications && ((_b = (_a = normalizedOptions.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, normalizedOptions, url || (context == null ? void 0 : context.url)) : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(authenticationLoader, url || "", normalizedOptions);
   context = getLoaderContext(
     // @ts-expect-error
     { url, _parse: parse, loaders: candidateLoaders },
@@ -3918,8 +4135,8 @@ function getTemporaryFilename(filename2) {
 }
 
 // dist/lib/api/create-data-source.js
-function createDataSource(data, sources, options) {
-  var _a;
+function createDataSource(data, sources, options = {}) {
+  var _a, _b, _c, _d, _e;
   const resolvedOptions = options || {};
   const type = ((_a = resolvedOptions == null ? void 0 : resolvedOptions.core) == null ? void 0 : _a.type) || resolvedOptions.type || "auto";
   const source = sources.length === 1 ? sources[0] : type === "auto" ? selectLoaderSync(data, sources, {
@@ -3931,7 +4148,23 @@ function createDataSource(data, sources, options) {
   if (!source) {
     throw new Error("Not a valid source type");
   }
-  return source.createDataSource(data, resolvedOptions, coreApi);
+  const contributions = ((_c = (_b = resolvedOptions.core) == null ? void 0 : _b.credentials) == null ? void 0 : _c.length) ? (_d = source.getAuthentications) == null ? void 0 : _d.call(source, typeof data === "string" ? data : "", resolvedOptions) : void 0;
+  if (contributions && "then" in contributions) {
+    void contributions.catch(() => {
+    });
+    throw new Error("Use load() with an asynchronous getAuthentications() hook.");
+  }
+  const authenticatedOptions = resolveAuthenticationOptions((contributions == null ? void 0 : contributions.length) ? {
+    ...resolvedOptions,
+    core: {
+      ...resolvedOptions.core,
+      authentications: [
+        ...((_e = resolvedOptions.core) == null ? void 0 : _e.authentications) || [],
+        ...contributions || []
+      ]
+    }
+  } : resolvedOptions);
+  return source.createDataSource(data, authenticatedOptions, coreApi);
 }
 function getSourceOfType(type, sources) {
   for (const service of sources) {
@@ -4005,7 +4238,7 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION4 = true ? "5.0.0-alpha.7" : "latest";
+var VERSION4 = true ? "5.0.0-alpha.9" : "latest";
 var NullWorkerLoader = {
   dataType: null,
   batchType: null,