@loaders.gl/core 4.4.2 → 5.0.0-alpha.1

package/dist/index.cjs

@@ -21,18 +21,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var dist_exports = {};
 __export(dist_exports, {
   FetchError: () => FetchError,
-  JSONLoader: () => import_loader_utils22.JSONLoader,
+  JSONLoader: () => import_loader_utils24.JSONLoader,
   NullLoader: () => NullLoader,
   NullWorkerLoader: () => NullWorkerLoader,
-  RequestScheduler: () => import_loader_utils21.RequestScheduler,
+  RequestScheduler: () => import_loader_utils23.RequestScheduler,
   _BrowserFileSystem: () => BrowserFileSystem,
   _fetchProgress: () => fetchProgress,
-  _selectSource: () => selectSource2,
+  _selectSource: () => selectSource,
   _unregisterLoaders: () => _unregisterLoaders,
-  assert: () => import_loader_utils24.assert,
-  concatenateArrayBuffersAsync: () => import_loader_utils25.concatenateArrayBuffersAsync,
+  assert: () => import_loader_utils26.assert,
+  concatenateArrayBuffersAsync: () => import_loader_utils27.concatenateArrayBuffersAsync,
+  coreApi: () => coreApi,
   createDataSource: () => createDataSource,
-  document: () => import_loader_utils23.document,
+  document: () => import_loader_utils25.document,
   encode: () => encode,
   encodeInBatches: () => encodeInBatches,
   encodeSync: () => encodeSync,
@@ -43,40 +44,43 @@ __export(dist_exports, {
   encodeTextSync: () => encodeTextSync,
   encodeURLtoURL: () => encodeURLtoURL,
   fetchFile: () => fetchFile,
-  forEach: () => import_loader_utils25.forEach,
+  forEach: () => import_loader_utils27.forEach,
   getLoaderOptions: () => getGlobalLoaderOptions,
-  getPathPrefix: () => import_loader_utils20.getPathPrefix,
-  global: () => import_loader_utils23.global,
-  isAsyncIterable: () => import_loader_utils27.isAsyncIterable,
-  isBrowser: () => import_loader_utils23.isBrowser,
-  isIterable: () => import_loader_utils27.isIterable,
-  isIterator: () => import_loader_utils27.isIterator,
-  isPromise: () => import_loader_utils27.isPromise,
-  isPureObject: () => import_loader_utils27.isPureObject,
-  isReadableStream: () => import_loader_utils27.isReadableStream,
-  isResponse: () => import_loader_utils27.isResponse,
-  isWorker: () => import_loader_utils23.isWorker,
-  isWritableStream: () => import_loader_utils27.isWritableStream,
+  getPathPrefix: () => import_loader_utils22.getPathPrefix,
+  global: () => import_loader_utils25.global,
+  isAsyncIterable: () => import_loader_utils29.isAsyncIterable,
+  isBrowser: () => import_loader_utils25.isBrowser,
+  isIterable: () => import_loader_utils29.isIterable,
+  isIterator: () => import_loader_utils29.isIterator,
+  isPromise: () => import_loader_utils29.isPromise,
+  isPureObject: () => import_loader_utils29.isPureObject,
+  isReadableStream: () => import_loader_utils29.isReadableStream,
+  isResponse: () => import_loader_utils29.isResponse,
+  isWorker: () => import_loader_utils25.isWorker,
+  isWritableStream: () => import_loader_utils29.isWritableStream,
   load: () => load,
   loadInBatches: () => loadInBatches,
   makeIterator: () => makeIterator,
-  makeLineIterator: () => import_loader_utils26.makeLineIterator,
-  makeNumberedLineIterator: () => import_loader_utils26.makeNumberedLineIterator,
+  makeLineIterator: () => import_loader_utils28.makeLineIterator,
+  makeNumberedLineIterator: () => import_loader_utils28.makeNumberedLineIterator,
   makeStream: () => makeStream,
-  makeTextDecoderIterator: () => import_loader_utils26.makeTextDecoderIterator,
-  makeTextEncoderIterator: () => import_loader_utils26.makeTextEncoderIterator,
+  makeTextDecoderIterator: () => import_loader_utils28.makeTextDecoderIterator,
+  makeTextEncoderIterator: () => import_loader_utils28.makeTextEncoderIterator,
   parse: () => parse,
+  parseFile: () => parseFile,
   parseInBatches: () => parseInBatches,
   parseSync: () => parseSync,
+  preload: () => preload,
+  preloadSync: () => preloadSync,
   readArrayBuffer: () => readArrayBuffer,
   registerLoaders: () => registerLoaders,
-  resolvePath: () => import_loader_utils20.resolvePath,
+  resolvePath: () => import_loader_utils22.resolvePath,
   selectLoader: () => selectLoader,
   selectLoaderSync: () => selectLoaderSync,
-  self: () => import_loader_utils23.self,
+  self: () => import_loader_utils25.self,
   setLoaderOptions: () => setGlobalOptions,
-  setPathPrefix: () => import_loader_utils20.setPathPrefix,
-  window: () => import_loader_utils23.window
+  setPathPrefix: () => import_loader_utils22.setPathPrefix,
+  window: () => import_loader_utils25.window
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -240,7 +244,7 @@ async function getResponseError(response) {
   try {
     const contentType = response.headers.get("Content-Type");
     info.reason = !response.bodyUsed && (contentType == null ? void 0 : contentType.includes("application/json")) ? await response.json() : await response.text();
-  } catch (error) {
+  } catch (_error) {
   }
   return new FetchError(message, info);
 }
@@ -327,37 +331,64 @@ var import_loader_utils5 = require("@loaders.gl/loader-utils");
 var import_log = require("@probe.gl/log");
 var probeLog = new import_log.Log({ id: "loaders.gl" });
 var NullLog = class {
+  /** Drops a log message. */
   log() {
     return () => {
     };
   }
+  /** Drops an info message. */
   info() {
     return () => {
     };
   }
+  /** Logs one message once; no-op for the null logger. */
+  once() {
+    return () => {
+    };
+  }
+  /** Drops a warning message. */
   warn() {
     return () => {
     };
   }
+  /** Drops an error message. */
   error() {
     return () => {
     };
   }
 };
 var ConsoleLog = class {
+  /** Console-like object used for message output. */
   console;
+  /** Messages already emitted through `once`. */
+  onceMessages = /* @__PURE__ */ new Set();
+  /** Creates a console-backed logger. */
   constructor() {
     this.console = console;
   }
+  /** Logs a message to the console. */
   log(...args) {
     return this.console.log.bind(this.console, ...args);
   }
+  /** Logs an informational message to the console. */
   info(...args) {
     return this.console.info.bind(this.console, ...args);
   }
+  /** Logs one message once to the console. */
+  once(...args) {
+    const message = String(args[0]);
+    if (this.onceMessages.has(message)) {
+      return () => {
+      };
+    }
+    this.onceMessages.add(message);
+    return this.console.info.bind(this.console, ...args);
+  }
+  /** Logs a warning message to the console. */
   warn(...args) {
     return this.console.warn.bind(this.console, ...args);
   }
+  /** Logs an error message to the console. */
   error(...args) {
     return this.console.error.bind(this.console, ...args);
   }
@@ -374,6 +405,7 @@ var DEFAULT_LOADER_OPTIONS = {
     fallbackMimeType: void 0,
     ignoreRegisteredLoaders: void 0,
     nothrow: false,
+    shape: void 0,
     log: new ConsoleLog(),
     // A probe.gl compatible (`log.log()()` syntax) that just logs to console
     useLocalLibraries: false,
@@ -419,6 +451,7 @@ var REMOVED_LOADER_OPTIONS = {
   _worker: "core._workerType",
   limit: "core.limit",
   _limitMB: "core._limitMB",
+  shape: "core.shape",
   batchSize: "core.batchSize",
   batchDebounceMs: "core.batchDebounceMs",
   metadata: "core.metadata",
@@ -457,10 +490,12 @@ var CORE_LOADER_OPTION_KEYS = [
   "maxConcurrency",
   "maxMobileConcurrency",
   "reuseWorkers",
+  "workerTransferBufferCopy",
   "_nodeWorkers",
   "_workerType",
   "limit",
   "_limitMB",
+  "shape",
   "batchSize",
   "batchDebounceMs",
   "metadata",
@@ -568,10 +603,35 @@ function normalizeOptionsInternal(loader, options, url) {
   mergeNestedFields(mergedOptions, normalizeLoaderOptions(getGlobalLoaderOptions()));
   const userOptions = normalizeLoaderOptions(options);
   mergeNestedFields(mergedOptions, userOptions);
+  applyCoreShapeDefault(mergedOptions, userOptions, loader);
   addUrlOptions(mergedOptions, url);
   addDeprecatedTopLevelOptions(mergedOptions);
   return mergedOptions;
 }
+function applyCoreShapeDefault(mergedOptions, userOptions, loader) {
+  var _a, _b;
+  const coreShape = (_a = mergedOptions.core) == null ? void 0 : _a.shape;
+  if (coreShape === void 0) {
+    return;
+  }
+  const loaderScopedDefaults = (_b = loader.options) == null ? void 0 : _b[loader.id];
+  if (!(0, import_loader_utils5.isPureObject)(loaderScopedDefaults) || !("shape" in loaderScopedDefaults)) {
+    return;
+  }
+  const globalLoaderScopedOptions = getGlobalLoaderOptions()[loader.id];
+  if ((0, import_loader_utils5.isPureObject)(globalLoaderScopedOptions) && "shape" in globalLoaderScopedOptions) {
+    return;
+  }
+  const userLoaderScopedOptions = userOptions[loader.id];
+  if ((0, import_loader_utils5.isPureObject)(userLoaderScopedOptions) && "shape" in userLoaderScopedOptions) {
+    return;
+  }
+  const loaderScopedOptions = mergedOptions[loader.id];
+  mergedOptions[loader.id] = {
+    ...(0, import_loader_utils5.isPureObject)(loaderScopedOptions) ? loaderScopedOptions : {},
+    shape: coreShape
+  };
+}
 function mergeNestedFields(mergedOptions, options) {
   for (const key in options) {
     if (key in options) {
@@ -614,7 +674,8 @@ function moveDeprecatedTopLevelOptionsToCore(options) {
   }
   for (const key of CORE_LOADER_OPTION_KEYS) {
     if (options[key] !== void 0) {
-      const coreOptions = options.core = options.core || {};
+      options.core ||= {};
+      const coreOptions = options.core;
       const coreRecord = coreOptions;
       if (coreRecord[key] === void 0) {
         coreRecord[key] = options[key];
@@ -765,16 +826,27 @@ function selectLoaderInternal(data, loaders, options, context) {
   const testUrl = stripQueryString(url) || (context == null ? void 0 : context.url);
   let loader = null;
   let reason = "";
+  const sourceType = (options == null ? void 0 : options.core) && "type" in options.core ? options.core.type : void 0;
+  if (sourceType && sourceType !== "auto") {
+    loader = findSourceLoaderByType(loaders, sourceType);
+    reason = loader ? `match forced by supplied source type ${sourceType}` : "";
+  }
   if ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.mimeType) {
     loader = findLoaderByMIMEType(loaders, (_b = options == null ? void 0 : options.core) == null ? void 0 : _b.mimeType);
     reason = `match forced by supplied MIME type ${(_c = options == null ? void 0 : options.core) == null ? void 0 : _c.mimeType}`;
   }
+  loader = loader || findSourceLoaderByTestURL(loaders, testUrl);
+  reason = reason || (loader ? `matched source url ${testUrl}` : "");
   loader = loader || findLoaderByUrl(loaders, testUrl);
   reason = reason || (loader ? `matched url ${testUrl}` : "");
   loader = loader || findLoaderByMIMEType(loaders, type);
   reason = reason || (loader ? `matched MIME type ${type}` : "");
   loader = loader || findLoaderByInitialBytes(loaders, data);
   reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
+  if (!loader && (0, import_loader_utils7.isBlob)(data)) {
+    loader = findSourceLoaderByTestData(loaders, data);
+    reason = reason || (loader ? "matched source testData" : "");
+  }
   if ((_d = options == null ? void 0 : options.core) == null ? void 0 : _d.fallbackMimeType) {
     loader = loader || findLoaderByMIMEType(loaders, (_e = options == null ? void 0 : options.core) == null ? void 0 : _e.fallbackMimeType);
     reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
@@ -824,6 +896,36 @@ function findLoaderByExtension(loaders, extension) {
   }
   return null;
 }
+function findSourceLoaderByType(loaders, type) {
+  for (const loader of loaders) {
+    if ((0, import_loader_utils7.isSourceLoader)(loader) && loader.type === type) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findSourceLoaderByTestURL(loaders, url) {
+  if (!url) {
+    return null;
+  }
+  for (const loader of loaders) {
+    if ((0, import_loader_utils7.isSourceLoader)(loader) && loader.testURL(url)) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findSourceLoaderByTestData(loaders, data) {
+  var _a;
+  for (const loader of loaders) {
+    if ((0, import_loader_utils7.isSourceLoader)(loader)) {
+      if ((_a = loader.testData) == null ? void 0 : _a.call(loader, data)) {
+        return loader;
+      }
+    }
+  }
+  return null;
+}
 function findLoaderByMIMEType(loaders, mimeType) {
   var _a;
   for (const loader of loaders) {
@@ -907,8 +1009,8 @@ function getMagicString(arrayBuffer, byteOffset, length) {
 }
 
 // dist/lib/api/parse.js
-var import_loader_utils14 = require("@loaders.gl/loader-utils");
-var import_worker_utils = require("@loaders.gl/worker-utils");
+var import_loader_utils18 = require("@loaders.gl/loader-utils");
+var import_worker_utils2 = require("@loaders.gl/worker-utils");
 
 // dist/lib/loader-utils/get-data.js
 var import_loader_utils11 = require("@loaders.gl/loader-utils");
@@ -977,7 +1079,7 @@ async function* makeBrowserStreamIterator(stream, options) {
       }
       yield (0, import_loader_utils9.toArrayBuffer)(value);
     }
-  } catch (error) {
+  } catch (_error) {
     reader.releaseLock();
   }
 }
@@ -1050,6 +1152,28 @@ async function getArrayBufferOrStringFromData(data, loader, options) {
   }
   throw new Error(ERR_DATA);
 }
+async function getArrayBufferFromData(data, options) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data).buffer;
+  }
+  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
+    return (0, import_loader_utils11.toArrayBuffer)((0, import_loader_utils11.toArrayBufferView)(data));
+  }
+  if ((0, import_loader_utils11.isBlob)(data)) {
+    data = await makeResponse(data);
+  }
+  if ((0, import_loader_utils11.isResponse)(data)) {
+    await checkResponse(data);
+    return await data.arrayBuffer();
+  }
+  if ((0, import_loader_utils11.isReadableStream)(data)) {
+    data = makeIterator(data, options);
+  }
+  if ((0, import_loader_utils11.isIterable)(data) || (0, import_loader_utils11.isAsyncIterable)(data)) {
+    return (0, import_loader_utils11.concatenateArrayBuffersAsync)(data);
+  }
+  throw new Error(ERR_DATA);
+}
 async function getAsyncIterableFromData(data, options) {
   if ((0, import_loader_utils11.isPromise)(data)) {
     data = await data;
@@ -1116,94 +1240,160 @@ function getFetchFunction(options, context) {
 }
 
 // dist/lib/loader-utils/loader-context.js
+var import_loader_utils17 = require("@loaders.gl/loader-utils");
+
+// dist/lib/api/parse-file.js
 var import_loader_utils13 = require("@loaders.gl/loader-utils");
-function getLoaderContext(context, options, parentContext) {
-  if (parentContext) {
-    return parentContext;
+var import_worker_utils = require("@loaders.gl/worker-utils");
+
+// dist/lib/api/load-loader.js
+var loaderImplementationPromises = /* @__PURE__ */ new Map();
+var loaderImplementations = /* @__PURE__ */ new Map();
+async function getLoaderImplementation(loader, options, url) {
+  var _a;
+  if (isLoaderWithParser(loader)) {
+    return loader;
   }
-  const newContext = {
-    fetch: getFetchFunction(options, context),
-    ...context
-  };
-  if (newContext.url) {
-    const baseUrl = stripQueryString(newContext.url);
-    newContext.baseUrl = baseUrl;
-    newContext.queryString = extractQueryString(newContext.url);
-    newContext.filename = import_loader_utils13.path.filename(baseUrl);
-    newContext.baseUrl = import_loader_utils13.path.dirname(baseUrl);
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader, options);
+  const loaderImplementation = (_a = loaderImplementations.get(loader)) == null ? void 0 : _a.get(implementationCacheKey);
+  if (loaderImplementation) {
+    return loaderImplementation;
+  }
+  let loaderImplementationPromisesForLoader = loaderImplementationPromises.get(loader);
+  if (!loaderImplementationPromisesForLoader) {
+    loaderImplementationPromisesForLoader = /* @__PURE__ */ new Map();
+    loaderImplementationPromises.set(loader, loaderImplementationPromisesForLoader);
+  }
+  let loaderImplementationPromise = loaderImplementationPromisesForLoader.get(implementationCacheKey);
+  if (!loaderImplementationPromise) {
+    loaderImplementationPromise = resolveLoaderImplementation(loader, options, url).then((implementation) => {
+      let loaderImplementationsForLoader = loaderImplementations.get(loader);
+      if (!loaderImplementationsForLoader) {
+        loaderImplementationsForLoader = /* @__PURE__ */ new Map();
+        loaderImplementations.set(loader, loaderImplementationsForLoader);
+      }
+      loaderImplementationsForLoader.set(implementationCacheKey, implementation);
+      return implementation;
+    }).catch((error) => {
+      loaderImplementationPromisesForLoader.delete(implementationCacheKey);
+      if (loaderImplementationPromisesForLoader.size === 0) {
+        loaderImplementationPromises.delete(loader);
+      }
+      throw error;
+    });
+    loaderImplementationPromisesForLoader.set(implementationCacheKey, loaderImplementationPromise);
   }
-  if (!Array.isArray(newContext.loaders)) {
-    newContext.loaders = null;
+  return await loaderImplementationPromise;
+}
+function getLoaderImplementationSync(loader) {
+  var _a;
+  if (isLoaderWithParser(loader)) {
+    return loader;
   }
-  return newContext;
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader);
+  return ((_a = loaderImplementations.get(loader)) == null ? void 0 : _a.get(implementationCacheKey)) || null;
 }
-function getLoadersFromContext(loaders, context) {
-  if (loaders && !Array.isArray(loaders)) {
-    return loaders;
+function isLoaderWithParser(loader) {
+  const candidate = loader;
+  return Boolean(candidate.parse || candidate.parseSync || candidate.parseInBatches || candidate.parseText || candidate.parseTextSync || candidate.parseFile || candidate.parseFileInBatches);
+}
+async function resolveLoaderImplementation(loader, options, url) {
+  if (loader.preload) {
+    const preloadedLoader = await loader.preload(url || "", options);
+    if (isLoaderWithParser(preloadedLoader)) {
+      return preloadedLoader;
+    }
+    throw new Error(`${loader.id} loader preload() did not return a parser-bearing loader`);
   }
-  let candidateLoaders;
-  if (loaders) {
-    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  const implementationSpecifier = getLoaderImplementationSpecifier(loader, options);
+  return await importLoaderImplementation(implementationSpecifier, loader.id);
+}
+function getLoaderImplementationSpecifier(loader, options) {
+  var _a;
+  const workerType = (options == null ? void 0 : options._workerType) || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
+  if (workerType === "test") {
+    const sourcePath = `modules/${loader.module}/src/${loader.id}-loader.ts`;
+    if (typeof window !== "undefined") {
+      return `/${sourcePath}`;
+    }
+    if (typeof process !== "undefined" && process.cwd) {
+      return new URL(sourcePath, `file://${process.cwd()}/`).toString();
+    }
+    return sourcePath;
   }
-  if (context && context.loaders) {
-    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
-    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  throw new Error(`${loader.id} loader does not provide a parser implementation. Import a parser-bearing loader directly, or use preload() before parse/load.`);
+}
+function getLoaderImplementationCacheKey(loader, options) {
+  var _a;
+  const loaderOptions = options == null ? void 0 : options[loader.id];
+  const defaultLoaderOptions = (_a = loader.options) == null ? void 0 : _a[loader.id];
+  return String((loaderOptions == null ? void 0 : loaderOptions.backend) || getDeprecatedImplementationBackend(loaderOptions == null ? void 0 : loaderOptions.implementation) || (defaultLoaderOptions == null ? void 0 : defaultLoaderOptions.backend) || "");
+}
+function getDeprecatedImplementationBackend(implementation) {
+  return implementation === "js" ? "typescript" : implementation;
+}
+async function importLoaderImplementation(implementationSpecifier, loaderId) {
+  const moduleExports = await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    implementationSpecifier
+  );
+  for (const exportValue of Object.values(moduleExports)) {
+    if (exportValue && typeof exportValue === "object" && exportValue.id === loaderId && isLoaderWithParser(exportValue)) {
+      return exportValue;
+    }
   }
-  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+  throw new Error(`Could not find parser implementation for ${loaderId} in ${implementationSpecifier}`);
 }
 
-// dist/lib/api/parse.js
-async function parse(data, loaders, options, context) {
+// dist/lib/api/parse-file.js
+async function parseFile(file, loaders, options, context) {
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
     loaders = void 0;
   }
-  data = await data;
   options = options || {};
-  const url = getResourceUrl(data);
+  const url = file.url || "";
   const typedLoaders = loaders;
   const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = await selectLoader(data, candidateLoaders, options);
+  const loader = await selectLoader(url, candidateLoaders, options);
   if (!loader) {
     return null;
   }
+  if ((0, import_loader_utils13.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);
   context = getLoaderContext(
-    // @ts-expect-error
+    // @ts-expect-error candidateLoaders may be a single forced loader
     { url, _parse: parse, loaders: candidateLoaders },
     strictOptions,
     context || null
   );
-  return await parseWithLoader(loader, data, strictOptions, context);
+  return await parseFileWithLoader(loader, file, strictOptions, context);
 }
-async function parseWithLoader(loader, data, options, context) {
+async function parseFileWithLoader(loader, file, options, context) {
   (0, import_worker_utils.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils14.mergeOptions)(loader.options, options);
-  if ((0, import_loader_utils14.isResponse)(data)) {
-    const { ok, redirected, status, statusText, type, url } = data;
-    const headers = Object.fromEntries(data.headers.entries());
-    context.response = { headers, ok, redirected, status, statusText, type, url };
-  }
-  data = await getArrayBufferOrStringFromData(data, loader, options);
-  const loaderWithParser = loader;
-  if (loaderWithParser.parseTextSync && typeof data === "string") {
-    return loaderWithParser.parseTextSync(data, options, context);
-  }
-  if ((0, import_loader_utils14.canParseWithWorker)(loader, options)) {
-    return await (0, import_loader_utils14.parseWithWorker)(loader, data, options, context, parse);
-  }
-  if (loaderWithParser.parseText && typeof data === "string") {
-    return await loaderWithParser.parseText(data, options, context);
-  }
-  if (loaderWithParser.parse) {
-    return await loaderWithParser.parse(data, options, context);
+  options = (0, import_loader_utils13.mergeOptions)(loader.options, options);
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if (loaderWithParser.parseFile) {
+    return await loaderWithParser.parseFile(file, options, context);
+  }
+  const parseFunction = loaderWithParser.parse;
+  if (parseFunction) {
+    const length = file.bigsize > 0n ? Number(file.bigsize) : file.size;
+    if (!length) {
+      throw new Error(`${loader.id} loader - cannot fall back to parse without a file size`);
+    }
+    const data = await file.read(0n, length);
+    return await parse(data, loaderWithParser, options, context);
   }
-  (0, import_worker_utils.assert)(!loaderWithParser.parseSync);
-  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+  throw new Error(`${loader.id} loader - no file parser found`);
 }
 
 // dist/lib/api/parse-sync.js
+var import_loader_utils14 = require("@loaders.gl/loader-utils");
 function parseSync(data, loaders, options, context) {
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
@@ -1217,13 +1407,17 @@ function parseSync(data, loaders, options, context) {
   if (!loader) {
     return null;
   }
+  if ((0, import_loader_utils14.isSourceLoader)(loader)) {
+    throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseSync().`);
+  }
   const strictOptions = normalizeOptions(options, loader, candidateLoaders);
   const url = getResourceUrl(data);
   const parse2 = () => {
     throw new Error("parseSync called parse (which is async");
   };
   context = getLoaderContext({ url, _parseSync: parse2, _parse: parse2, loaders }, strictOptions, context || null);
-  return parseWithLoaderSync(loader, data, strictOptions, context);
+  const loaderWithParser = getLoaderImplementationSync(loader);
+  return parseWithLoaderSync(loaderWithParser || loader, data, strictOptions, context);
 }
 function parseWithLoaderSync(loader, data, options, context) {
   data = getArrayBufferOrStringFromDataSync(data, loader, options);
@@ -1233,6 +1427,9 @@ function parseWithLoaderSync(loader, data, options, context) {
   if (loader.parseSync && data instanceof ArrayBuffer) {
     return loader.parseSync(data, options, context);
   }
+  if (loader.preload) {
+    throw new Error(`${loader.name} loader: 'parseSync' requires a parser-bearing loader. Import the loader implementation directly, or call preload(loader) before parseSync(). ${context.url || ""}`);
+  }
   throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ""}`);
 }
 
@@ -1255,9 +1452,10 @@ async function parseInBatches(data, loaders, options, context) {
   }
   const strictOptions = normalizeOptions(options, loader, loaderArray, url);
   context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, strictOptions, context || null);
-  return await parseWithLoaderInBatches(loader, data, strictOptions, context);
+  const loaderWithParser = await getLoaderImplementation(loader, strictOptions, context.url);
+  return await parseWithLoaderInBatches(loader, loaderWithParser, data, strictOptions, context);
 }
-async function parseWithLoaderInBatches(loader, data, options, context) {
+async function parseWithLoaderInBatches(originalLoader, loader, data, options, context) {
   var _a;
   const outputIterator = await parseToOutputIterator(loader, data, options, context);
   if (!((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.metadata)) {
@@ -1267,7 +1465,7 @@ async function parseWithLoaderInBatches(loader, data, options, context) {
     shape: "metadata",
     batchType: "metadata",
     metadata: {
-      _loader: loader,
+      _loader: originalLoader,
       _context: context
     },
     // Populate with some default fields to avoid crashing
@@ -1321,6 +1519,34 @@ async function applyInputTransforms(inputIterator, transforms = []) {
 
 // dist/lib/api/load.js
 var import_loader_utils16 = require("@loaders.gl/loader-utils");
+
+// dist/lib/api/load-in-batches.js
+function loadInBatches(files, loaders, options, context) {
+  let loadersArray;
+  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = void 0;
+    options = loaders;
+    loadersArray = void 0;
+  } else {
+    loadersArray = loaders;
+  }
+  const fetch2 = getFetchFunction(options || {});
+  if (!Array.isArray(files)) {
+    return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+  }
+  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
+  return promises;
+}
+async function loadOneFileInBatches(file, loaders, options, fetch2) {
+  if (typeof file === "string") {
+    const url = file;
+    const response = await fetch2(url);
+    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);
+}
+
+// dist/lib/api/load.js
 async function load(url, loaders, options, context) {
   var _a;
   let resolvedLoaders;
@@ -1333,6 +1559,47 @@ async function load(url, loaders, options, context) {
     resolvedLoaders = loaders;
     resolvedOptions = options;
   }
+  if (!Array.isArray(resolvedLoaders) && (0, import_loader_utils16.isSourceLoader)(resolvedLoaders)) {
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return resolvedLoaders.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+  }
+  if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && (0, import_loader_utils16.isSourceLoader)(resolvedLoaders[0])) {
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return resolvedLoaders[0].createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+  }
+  if (typeof url === "string" || (0, import_loader_utils16.isBlob)(url)) {
+    const selectedLoader = await selectLoader(url, resolvedLoaders, {
+      ...resolvedOptions,
+      core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, nothrow: true }
+    });
+    if (selectedLoader && (0, import_loader_utils16.isSourceLoader)(selectedLoader)) {
+      return selectedLoader.createDataSource(url, resolvedOptions || {}, {
+        fetchFile,
+        parse,
+        parseFile,
+        parseSync,
+        parseInBatches,
+        load,
+        loadInBatches
+      });
+    }
+  }
   const fetch2 = getFetchFunction(resolvedOptions);
   let data = url;
   if (typeof url === "string") {
@@ -1353,44 +1620,134 @@ async function load(url, loaders, options, context) {
       };
     }
   }
-  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
+  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions, context) : await parse(data, resolvedLoaders, resolvedOptions, context);
 }
 
-// dist/lib/api/load-in-batches.js
-function loadInBatches(files, loaders, options, context) {
-  let loadersArray;
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+// dist/lib/api/core-api.js
+var coreApi = Object.freeze({
+  fetchFile,
+  parse,
+  parseFile,
+  parseSync,
+  parseInBatches,
+  load,
+  loadInBatches
+});
+
+// dist/lib/loader-utils/loader-context.js
+function getLoaderContext(context, options, parentContext) {
+  if (parentContext) {
+    return parentContext;
+  }
+  const newContext = {
+    ...context,
+    fetch: getFetchFunction(options, context),
+    coreApi: context.coreApi || coreApi
+  };
+  if (newContext.url) {
+    const baseUrl = stripQueryString(newContext.url);
+    newContext.baseUrl = baseUrl;
+    newContext.queryString = extractQueryString(newContext.url);
+    newContext.filename = import_loader_utils17.path.filename(baseUrl);
+    newContext.baseUrl = import_loader_utils17.path.dirname(baseUrl);
+  }
+  if (!Array.isArray(newContext.loaders)) {
+    newContext.loaders = null;
+  }
+  return newContext;
+}
+function getLoadersFromContext(loaders, context) {
+  if (loaders && !Array.isArray(loaders)) {
+    return loaders;
+  }
+  let candidateLoaders;
+  if (loaders) {
+    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  }
+  if (context && context.loaders) {
+    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  }
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+}
+
+// dist/lib/api/parse.js
+async function parse(data, loaders, options, context) {
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
-    loadersArray = void 0;
-  } else {
-    loadersArray = loaders;
+    loaders = void 0;
   }
-  const fetch2 = getFetchFunction(options || {});
-  if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+  data = await data;
+  options = options || {};
+  const url = getResourceUrl(data);
+  const typedLoaders = loaders;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(data, candidateLoaders, options);
+  if (!loader) {
+    return null;
   }
-  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
-  return promises;
+  if ((0, import_loader_utils18.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);
+  context = getLoaderContext(
+    // @ts-expect-error
+    { url, _parse: parse, loaders: candidateLoaders },
+    strictOptions,
+    context || null
+  );
+  return await parseWithLoader(loader, data, strictOptions, context);
 }
-async function loadOneFileInBatches(file, loaders, options, fetch2) {
-  if (typeof file === "string") {
-    const url = file;
-    const response = await fetch2(url);
-    return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
+async function parseWithLoader(loader, data, options, context) {
+  (0, import_worker_utils2.validateWorkerVersion)(loader);
+  options = (0, import_loader_utils18.mergeOptions)(loader.options, options);
+  if ((0, import_loader_utils18.isResponse)(data)) {
+    const { ok, redirected, status, statusText, type, url } = data;
+    const headers = Object.fromEntries(data.headers.entries());
+    context.response = { headers, ok, redirected, status, statusText, type, url };
   }
-  return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if ((0, import_loader_utils18.canParseWithWorker)(loaderWithParser, options)) {
+    data = await getArrayBufferFromData(data, options);
+    return await (0, import_loader_utils18.parseWithWorker)(loaderWithParser, data, options, context, parse);
+  }
+  data = await getArrayBufferOrStringFromData(data, loader, options);
+  return await parseWithLoaderImplementation(loaderWithParser, data, options, context);
+}
+async function parseWithLoaderImplementation(loader, data, options, context) {
+  if (loader.parseText && typeof data === "string") {
+    return await loader.parseText(data, options, context);
+  }
+  if (loader.parseTextSync && typeof data === "string") {
+    return loader.parseTextSync(data, options, context);
+  }
+  if (loader.parse) {
+    return await loader.parse(data, options, context);
+  }
+  if (loader.parseSync) {
+    throw new Error(`${loader.name} loader: 'parse' not available on parser-bearing sync loader. Add an async 'parse' function to this loader, or call preload(loader) before parseSync(). ${context.url || ""}`);
+  }
+  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+}
+
+// dist/lib/api/preload.js
+async function preload(loader, options, url) {
+  return await getLoaderImplementation(loader, options, url);
+}
+function preloadSync(loader) {
+  return getLoaderImplementationSync(loader);
 }
 
 // dist/lib/api/encode-table.js
-var import_loader_utils17 = require("@loaders.gl/loader-utils");
+var import_loader_utils19 = require("@loaders.gl/loader-utils");
 async function encodeTable(data, writer, options) {
   if (writer.encode) {
     return await writer.encode(data, options);
   }
   if (writer.encodeText) {
     const text = await writer.encodeText(data, options);
-    return (0, import_loader_utils17.ensureArrayBuffer)(new TextEncoder().encode(text));
+    return (0, import_loader_utils19.ensureArrayBuffer)(new TextEncoder().encode(text));
   }
   if (writer.encodeInBatches) {
     const batches = encodeTableInBatches(data, writer, options);
@@ -1398,7 +1755,7 @@ async function encodeTable(data, writer, options) {
     for await (const batch of batches) {
       chunks.push(batch);
     }
-    return (0, import_loader_utils17.concatenateArrayBuffers)(...chunks);
+    return (0, import_loader_utils19.concatenateArrayBuffers)(...chunks);
   }
   throw new Error("Writer could not encode data");
 }
@@ -1425,16 +1782,16 @@ function getIterator(data) {
 }
 
 // dist/lib/api/encode.js
-var import_loader_utils18 = require("@loaders.gl/loader-utils");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
+var import_loader_utils20 = require("@loaders.gl/loader-utils");
+var import_worker_utils3 = require("@loaders.gl/worker-utils");
 async function encode(data, writer, options_) {
   const globalOptions = getGlobalLoaderOptions();
   const options = { ...globalOptions, ...options_ };
   if (writer.encodeURLtoURL) {
     return encodeWithCommandLineTool(writer, data, options);
   }
-  if ((0, import_loader_utils18.canEncodeWithWorker)(writer, options)) {
-    return await (0, import_worker_utils2.processOnWorker)(writer, data, options);
+  if ((0, import_loader_utils20.canEncodeWithWorker)(writer, options)) {
+    return await (0, import_worker_utils3.processOnWorker)(writer, data, options);
   }
   return await writer.encode(data, options);
 }
@@ -1443,7 +1800,7 @@ function encodeSync(data, writer, options) {
     return writer.encodeSync(data, options);
   }
   if (writer.encodeTextSync) {
-    return (0, import_loader_utils18.ensureArrayBuffer)(new TextEncoder().encode(writer.encodeTextSync(data, options)));
+    return (0, import_loader_utils20.ensureArrayBuffer)(new TextEncoder().encode(writer.encodeTextSync(data, options)));
   }
   throw new Error(`Writer ${writer.name} could not synchronously encode data`);
 }
@@ -1478,20 +1835,20 @@ function encodeInBatches(data, writer, options) {
   throw new Error(`Writer ${writer.name} could not encode in batches`);
 }
 async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
-  inputUrl = (0, import_loader_utils18.resolvePath)(inputUrl);
-  outputUrl = (0, import_loader_utils18.resolvePath)(outputUrl);
-  if (import_loader_utils18.isBrowser || !writer.encodeURLtoURL) {
+  inputUrl = (0, import_loader_utils20.resolvePath)(inputUrl);
+  outputUrl = (0, import_loader_utils20.resolvePath)(outputUrl);
+  if (import_loader_utils20.isBrowser || !writer.encodeURLtoURL) {
     throw new Error();
   }
   const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
   return outputFilename;
 }
 async function encodeWithCommandLineTool(writer, data, options) {
-  if (import_loader_utils18.isBrowser) {
+  if (import_loader_utils20.isBrowser) {
     throw new Error(`Writer ${writer.name} not supported in browser`);
   }
   const tmpInputFilename = getTemporaryFilename("input");
-  const file = new import_loader_utils18.NodeFile(tmpInputFilename, "w");
+  const file = new import_loader_utils20.NodeFile(tmpInputFilename, "w");
   await file.write(data);
   const tmpOutputFilename = getTemporaryFilename("output");
   const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
@@ -1509,20 +1866,18 @@ function getTemporaryFilename(filename) {
 // dist/lib/api/create-data-source.js
 function createDataSource(data, sources, options) {
   var _a;
-  const type = ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.type) || options.type || "auto";
-  const source = type === "auto" ? selectSource(data, sources) : getSourceOfType(type, sources);
+  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, {
+    // `createDataSource` supports non-fetch inputs such as in-memory tables.
+    // Selection remains best-effort for those cases.
+    ...resolvedOptions,
+    core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, type: "auto" }
+  }) : getSourceOfType(type, sources);
   if (!source) {
     throw new Error("Not a valid source type");
   }
-  return source.createDataSource(data, options);
-}
-function selectSource(url, sources) {
-  for (const service of sources) {
-    if (service.testURL && service.testURL(url)) {
-      return service;
-    }
-  }
-  return null;
+  return source.createDataSource(data, resolvedOptions, coreApi);
 }
 function getSourceOfType(type, sources) {
   for (const service of sources) {
@@ -1534,15 +1889,11 @@ function getSourceOfType(type, sources) {
 }
 
 // dist/lib/api/select-source.js
-function selectSource2(url, sources, options) {
+function selectSource(url, sources, options) {
   const type = (options == null ? void 0 : options.type) || "auto";
   let selectedSource = null;
   if (type === "auto") {
-    for (const source of sources) {
-      if (typeof url === "string" && source.testURL && source.testURL(url)) {
-        return source;
-      }
-    }
+    selectedSource = selectLoaderSync(url, sources, { core: { nothrow: true } });
   } else {
     selectedSource = getSourceOfType2(type, sources);
   }
@@ -1561,8 +1912,8 @@ function getSourceOfType2(type, sources) {
 }
 
 // dist/index.js
-var import_loader_utils20 = require("@loaders.gl/loader-utils");
-var import_loader_utils21 = require("@loaders.gl/loader-utils");
+var import_loader_utils22 = require("@loaders.gl/loader-utils");
+var import_loader_utils23 = require("@loaders.gl/loader-utils");
 
 // dist/iterators/make-stream/make-stream.js
 function makeStream(source, options) {
@@ -1604,7 +1955,7 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION = true ? "4.4.2" : "latest";
+var VERSION = true ? "5.0.0-alpha.1" : "latest";
 var NullWorkerLoader = {
   dataType: null,
   batchType: null,
@@ -1646,7 +1997,7 @@ function parseSync2(arrayBuffer, options, context) {
 }
 
 // dist/index.js
-var import_loader_utils22 = require("@loaders.gl/loader-utils");
+var import_loader_utils24 = require("@loaders.gl/loader-utils");
 
 // dist/lib/progress/fetch-progress.js
 async function fetchProgress(response, onProgress, onDone = () => {
@@ -1696,7 +2047,7 @@ async function read(controller, reader, loadedBytes, totalBytes, onProgress, onD
 }
 
 // dist/lib/filesystems/browser-filesystem.js
-var import_loader_utils19 = require("@loaders.gl/loader-utils");
+var import_loader_utils21 = require("@loaders.gl/loader-utils");
 var BrowserFileSystem = class {
   _fetch;
   files = {};
@@ -1778,7 +2129,7 @@ var BrowserFileSystem = class {
   // implements IRandomAccessFileSystem
   // RANDOM ACCESS
   async openReadableFile(pathname, flags) {
-    return new import_loader_utils19.BlobFile(this.files[pathname]);
+    return new import_loader_utils21.BlobFile(this.files[pathname]);
   }
   // PRIVATE
   // Supports case independent paths, and file usage tracking
@@ -1792,9 +2143,9 @@ var BrowserFileSystem = class {
 };
 
 // dist/index.js
-var import_loader_utils23 = require("@loaders.gl/loader-utils");
-var import_loader_utils24 = require("@loaders.gl/loader-utils");
 var import_loader_utils25 = require("@loaders.gl/loader-utils");
 var import_loader_utils26 = require("@loaders.gl/loader-utils");
 var import_loader_utils27 = require("@loaders.gl/loader-utils");
+var import_loader_utils28 = require("@loaders.gl/loader-utils");
+var import_loader_utils29 = require("@loaders.gl/loader-utils");
 //# sourceMappingURL=index.cjs.map