tiny-essentials 1.29.0 → 1.29.2

package/dist/v1/libs/html/loader/formats/TinyFetchLoader.cjs

@@ -0,0 +1,225 @@
+'use strict';
+
+var TinyMediaLoader = require('../TinyMediaLoader.cjs');
+
+/**
+ * @fileoverview Generic file loader for external resources.
+ * Uses the native `fetch` API by default, but accepts any implementation
+ * that follows the same contract: `(input, init) => Promise<Response>`.
+ */
+
+/**
+ * The response body types supported by the loader.
+ * @typedef {'blob'|'arraybuffer'|'text'|'json'} FetchResponseType
+ */
+
+/**
+ * Describes the configuration accepted by the {@link TinyFetchLoader} constructor.
+ * @typedef {Object} FetchLoaderOptions
+ * @property {string} [src] - The file URL.
+ * @property {RequestInit} [init] - The fetch options (method, headers, body, credentials, mode, cache, redirect, referrer, referrerPolicy, integrity, keepalive).
+ * @property {typeof fetch} [fetch] - A custom fetch implementation.
+ * @property {FetchResponseType} [responseType] - The response body type (default `'blob'`).
+ * @property {number} [timeout] - Maximum time in milliseconds before the load is aborted.
+ * @property {boolean} [useHeadRequest] - Whether to perform a HEAD request before downloading.
+ * @property {BodyInit} [body] - The request body forwarded to the transport (ignored by `GET`/`HEAD`).
+ * @property {boolean} [progressive] - Whether to emit progress events (default `true`).
+ * @property {boolean} [mirror] - Whether concurrent loads of the same source share a single download (default `true`).
+ * @property {import('../utils/TinyMediaCache.mjs').default|null} [cache] - An optional shared memory cache.
+ */
+
+/**
+ * The signature of the function returned by {@link TinyFetchLoader#exportFetch}.
+ * @typedef {(input: string|URL|Request, init?: RequestInit) => Promise<Response>} TinyFetch
+ */
+
+/**
+ * Loads an arbitrary file through the native `fetch` API.
+ *
+ * The class does not create a DOM element. It reuses the state machine,
+ * progress tracker, cache and mirror registry of {@link TinyMediaLoader},
+ * and exposes the downloaded payload through {@link TinyFetchLoader#blob}
+ * and {@link TinyFetchLoader#data}.
+ * @extends {TinyMediaLoader<any>}
+ */
+class TinyFetchLoader extends TinyMediaLoader {
+  /** @type {RequestInit} */
+  #init;
+  /** @type {FetchResponseType} */
+  #responseType;
+  /** @type {Blob|null} */
+  #blob = null;
+  /** @type {Blob|ArrayBuffer|string|unknown|null} */
+  #data = null;
+  /** @type {FetchLoaderOptions} */
+  #options;
+
+  /**
+   * @param {FetchLoaderOptions} [options] - The loader configuration.
+   * @throws {TypeError} If `fetch` is not a function.
+   * @throws {TypeError} If `init` is not a plain object.
+   * @throws {RangeError} If `responseType` is not supported.
+   */
+  constructor(options = {}) {
+    if (options === null || typeof options !== 'object' || Array.isArray(options)) {
+      throw new TypeError('The "options" argument must be a plain object.');
+    }
+    super(options);
+
+    const {
+      fetch: fetcher = globalThis.fetch.bind(globalThis),
+      init = {},
+      responseType = 'blob',
+    } = options;
+
+    if (typeof fetcher !== 'function') {
+      throw new TypeError('The "fetch" option must be a function.');
+    }
+    if (init === null || typeof init !== 'object' || Array.isArray(init)) {
+      throw new TypeError('The "init" option must be a plain object.');
+    }
+    if (!['blob', 'arraybuffer', 'text', 'json'].includes(responseType)) {
+      throw new RangeError(
+        'The "responseType" option must be one of: blob, arraybuffer, text, json.',
+      );
+    }
+
+    this._fetch = fetcher;
+    this._requestInit = init;
+    this.#init = init;
+    this.#responseType = responseType;
+    this.#options = { ...options, fetch: fetcher, init: { ...init }, responseType };
+  }
+
+  /**
+   * The downloaded file, or null before the load finishes.
+   * @returns {Blob|null} The raw payload.
+   */
+  get blob() {
+    return this.#blob;
+  }
+
+  /**
+   * The parsed payload, in the format requested by `responseType`.
+   * @returns {Blob|ArrayBuffer|string|unknown|null} The parsed payload.
+   */
+  get data() {
+    return this.#data;
+  }
+
+  /**
+   * The response body type requested at construction time.
+   * @returns {FetchResponseType} The response body type.
+   */
+  get responseType() {
+    return this.#responseType;
+  }
+
+  /**
+   * The fetch options forwarded to the transport.
+   * @returns {RequestInit} A defensive copy of the fetch options.
+   */
+  get init() {
+    return { ...this.#init };
+  }
+
+  /**
+   * Creates a new loader with the same configuration.
+   *
+   * The clone is fully independent: it has its own state machine, its own
+   * abort controller and its own `blob`/`data` slots. The shared `cache` and
+   * the custom `fetch` implementation are reused by reference, which is what
+   * makes {@link TinyFetchLoader#exportFetch} cheap.
+   * @param {FetchLoaderOptions} [overrides] - Values that override the cloned configuration.
+   * @returns {TinyFetchLoader} A new, independent loader.
+   * @throws {TypeError} If `overrides` is not a plain object.
+   */
+  clone(overrides = {}) {
+    if (overrides === null || typeof overrides !== 'object' || Array.isArray(overrides)) {
+      throw new TypeError('The "overrides" argument must be a plain object.');
+    }
+    const init = { ...this.#options.init, ...(overrides.init ?? {}) };
+    return new TinyFetchLoader({ ...this.#options, ...overrides, init });
+  }
+
+  /**
+   * Returns a `fetch`-compatible function backed by this loader.
+   * @returns {TinyFetch} A function with the same signature as `fetch`.
+   */
+  exportFetch() {
+    const self = this;
+    return async function tinyFetch(input, init) {
+      return self._fetch(input, init);
+    };
+  }
+
+  /**
+   * Downloads the file, consulting the shared cache first.
+   * @protected
+   * @returns {Promise<void>} Resolves once the payload is ready.
+   */
+  async _startLoad() {
+    const cached = this._acquireFromCache();
+    if (cached) {
+      this.emit('cachehit', cached);
+      this.#blob = cached.blob;
+      await this.#parse(cached.blob);
+      return;
+    }
+
+    const blob = await this._downloadStream(this.src);
+    this.#blob = blob;
+    this._setResourceSize(blob.size);
+
+    if (this.cache) {
+      this._cacheBlob(blob);
+    }
+
+    await this.#parse(blob);
+  }
+
+  /**
+   * Converts the raw blob into the format requested by `responseType`.
+   * @param {Blob} blob - The downloaded or cached payload.
+   * @returns {Promise<void>} Resolves once `data` is populated.
+   * @throws {SyntaxError} If `responseType` is `'json'` and the body is not valid JSON.
+   */
+  async #parse(blob) {
+    if (this.#responseType === 'arraybuffer') {
+      this.#data = await blob.arrayBuffer();
+    } else if (this.#responseType === 'text') {
+      this.#data = await blob.text();
+    } else if (this.#responseType === 'json') {
+      this.#data = JSON.parse(await blob.text());
+    } else {
+      this.#data = blob;
+    }
+  }
+
+  /**
+   * Builds the metadata descriptor for the loaded file.
+   * @protected
+   * @returns {import('../TinyMediaLoader.mjs').MediaMetadataDetails} The file metadata.
+   */
+  _getMetadataDetails() {
+    return {
+      type: this.#blob?.type || 'application/octet-stream',
+      width: 0,
+      height: 0,
+      duration: 0,
+      size: this.#blob?.size ?? 0,
+    };
+  }
+
+  /**
+   * `TinyFetchLoader` does not render anything, so this method always throws.
+   * @protected
+   * @returns {never} This method never returns.
+   * @throws {Error} Always.
+   */
+  _createElement() {
+    throw new Error('TinyFetchLoader does not create a DOM element.');
+  }
+}
+
+module.exports = TinyFetchLoader;

package/dist/v1/libs/html/loader/formats/TinyFetchLoader.d.mts

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Generic file loader for external resources.
+ * Uses the native `fetch` API by default, but accepts any implementation
+ * that follows the same contract: `(input, init) => Promise<Response>`.
+ */
+import TinyMediaLoader from '../TinyMediaLoader.mjs';
+export type FetchResponseType = 'blob' | 'arraybuffer' | 'text' | 'json';
+export type FetchLoaderOptions = {
+    /**
+     * - The file URL.
+     */
+    src?: string;
+    /**
+     * - The fetch options (method, headers, body, credentials, mode, cache, redirect, referrer, referrerPolicy, integrity, keepalive).
+     */
+    init?: RequestInit;
+    /**
+     * - A custom fetch implementation.
+     */
+    fetch?: typeof fetch;
+    /**
+     * - The response body type (default `'blob'`).
+     */
+    responseType?: FetchResponseType;
+    /**
+     * - Maximum time in milliseconds before the load is aborted.
+     */
+    timeout?: number;
+    /**
+     * - Whether to perform a HEAD request before downloading.
+     */
+    useHeadRequest?: boolean;
+    /**
+     * - The request body forwarded to the transport (ignored by `GET`/`HEAD`).
+     */
+    body?: BodyInit;
+    /**
+     * - Whether to emit progress events (default `true`).
+     */
+    progressive?: boolean;
+    /**
+     * - Whether concurrent loads of the same source share a single download (default `true`).
+     */
+    mirror?: boolean;
+    /**
+     * - An optional shared memory cache.
+     */
+    cache?: import('../utils/TinyMediaCache.mjs').default | null;
+};
+export type TinyFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * The response body types supported by the loader.
+ * @typedef {'blob'|'arraybuffer'|'text'|'json'} FetchResponseType
+ */
+/**
+ * Describes the configuration accepted by the {@link TinyFetchLoader} constructor.
+ * @typedef {Object} FetchLoaderOptions
+ * @property {string} [src] - The file URL.
+ * @property {RequestInit} [init] - The fetch options (method, headers, body, credentials, mode, cache, redirect, referrer, referrerPolicy, integrity, keepalive).
+ * @property {typeof fetch} [fetch] - A custom fetch implementation.
+ * @property {FetchResponseType} [responseType] - The response body type (default `'blob'`).
+ * @property {number} [timeout] - Maximum time in milliseconds before the load is aborted.
+ * @property {boolean} [useHeadRequest] - Whether to perform a HEAD request before downloading.
+ * @property {BodyInit} [body] - The request body forwarded to the transport (ignored by `GET`/`HEAD`).
+ * @property {boolean} [progressive] - Whether to emit progress events (default `true`).
+ * @property {boolean} [mirror] - Whether concurrent loads of the same source share a single download (default `true`).
+ * @property {import('../utils/TinyMediaCache.mjs').default|null} [cache] - An optional shared memory cache.
+ */
+/**
+ * The signature of the function returned by {@link TinyFetchLoader#exportFetch}.
+ * @typedef {(input: string|URL|Request, init?: RequestInit) => Promise<Response>} TinyFetch
+ */
+/**
+ * Loads an arbitrary file through the native `fetch` API.
+ *
+ * The class does not create a DOM element. It reuses the state machine,
+ * progress tracker, cache and mirror registry of {@link TinyMediaLoader},
+ * and exposes the downloaded payload through {@link TinyFetchLoader#blob}
+ * and {@link TinyFetchLoader#data}.
+ * @extends {TinyMediaLoader<any>}
+ */
+declare class TinyFetchLoader extends TinyMediaLoader<any> {
+    #private;
+    /**
+     * @param {FetchLoaderOptions} [options] - The loader configuration.
+     * @throws {TypeError} If `fetch` is not a function.
+     * @throws {TypeError} If `init` is not a plain object.
+     * @throws {RangeError} If `responseType` is not supported.
+     */
+    constructor(options?: FetchLoaderOptions);
+    /**
+     * The downloaded file, or null before the load finishes.
+     * @returns {Blob|null} The raw payload.
+     */
+    get blob(): Blob | null;
+    /**
+     * The parsed payload, in the format requested by `responseType`.
+     * @returns {Blob|ArrayBuffer|string|unknown|null} The parsed payload.
+     */
+    get data(): Blob | ArrayBuffer | string | unknown | null;
+    /**
+     * The response body type requested at construction time.
+     * @returns {FetchResponseType} The response body type.
+     */
+    get responseType(): FetchResponseType;
+    /**
+     * The fetch options forwarded to the transport.
+     * @returns {RequestInit} A defensive copy of the fetch options.
+     */
+    get init(): RequestInit;
+    /**
+     * Creates a new loader with the same configuration.
+     *
+     * The clone is fully independent: it has its own state machine, its own
+     * abort controller and its own `blob`/`data` slots. The shared `cache` and
+     * the custom `fetch` implementation are reused by reference, which is what
+     * makes {@link TinyFetchLoader#exportFetch} cheap.
+     * @param {FetchLoaderOptions} [overrides] - Values that override the cloned configuration.
+     * @returns {TinyFetchLoader} A new, independent loader.
+     * @throws {TypeError} If `overrides` is not a plain object.
+     */
+    clone(overrides?: FetchLoaderOptions): TinyFetchLoader;
+    /**
+     * Returns a `fetch`-compatible function backed by this loader.
+     * @returns {TinyFetch} A function with the same signature as `fetch`.
+     */
+    exportFetch(): TinyFetch;
+    /**
+     * Downloads the file, consulting the shared cache first.
+     * @protected
+     * @returns {Promise<void>} Resolves once the payload is ready.
+     */
+    protected _startLoad(): Promise<void>;
+    /**
+     * Builds the metadata descriptor for the loaded file.
+     * @protected
+     * @returns {import('../TinyMediaLoader.mjs').MediaMetadataDetails} The file metadata.
+     */
+    protected _getMetadataDetails(): import('../TinyMediaLoader.mjs').MediaMetadataDetails;
+    /**
+     * `TinyFetchLoader` does not render anything, so this method always throws.
+     * @protected
+     * @returns {never} This method never returns.
+     * @throws {Error} Always.
+     */
+    protected _createElement(): never;
+}
+export default TinyFetchLoader;
+//# sourceMappingURL=TinyFetchLoader.d.mts.map

package/dist/v1/libs/html/loader/formats/TinyFetchLoader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TinyFetchLoader.d.mts","sourceRoot":"","sources":["../../../../../../src/v1/libs/html/loader/formats/TinyFetchLoader.mjs"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,eAAe,MAAM,wBAAwB,CAAC;AAIlD,YAA8C,iBAAiB,GAArD,MAAM,GAAC,aAAa,GAAC,MAAM,GAAC,MAAM,CAAmB;AAK/D,YAAkB,kBAAkB,GACpC;;;;IAAoB,GAAG,AAAvB,CACA,EADW,MAAM,CACjB;;;;IAAyB,IAAI,AAA7B,CACA,EADW,WAAW,CACtB;;;;IAA0B,KAAK,AAA/B,CACA,EADW,OAAO,KAAK,CACvB;;;;IAA+B,YAAY,AAA3C,CACA,EADW,iBAAiB,CAC5B;;;;IAAoB,OAAO,AAA3B,CACA,EADW,MAAM,CACjB;;;;IAAqB,cAAc,AAAnC,CACA,EADW,OAAO,CAClB;;;;IAAsB,IAAI,AAA1B,CACA,EADW,QAAQ,CACnB;;;;IAAqB,WAAW,AAAhC,CACA,EADW,OAAO,CAClB;;;;IAAqB,MAAM,AAA3B,CACA,EADW,OAAO,CAClB;;;;IAAgE,KAAK,AAArE,CACF,EADa,OAAO,6BAA6B,EAAE,OAAO,GAAC,IAAI,CAC/D;CAAA,CAAA;AAIE,YAAgF,SAAS,GAA/E,CAAC,KAAK,EAAE,MAAM,GAAC,GAAG,GAAC,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAW;AAtB5F;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AACH,cAAM,eAAgB,SAAQ,eAAe,CAFhB,GAAG,CAEa;;IAY3C;;;;;OAKG;IACH,YAAY,OAAO,AALhB,CACA,EADQ,kBAKa,EA6BvB;IAED;;;OAGG;IACH,IAAI,IAAI,IAFK,IAAI,GAAC,IAAI,CAIrB;IAED;;;OAGG;IACH,IAAI,IAAI,IAFK,IAAI,GAAC,WAAW,GAAC,MAAM,GAAC,OAAO,GAAC,IAAI,CAIhD;IAED;;;OAGG;IACH,IAAI,YAAY,IAFH,iBAAiB,CAI7B;IAED;;;OAGG;IACH,IAAI,IAAI,IAFK,WAAW,CAIvB;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,SAAS,AAJZ,CACA,EADQ,kBAIS,GAHP,eAAe,CAS3B;IAED;;;OAGG;IACH,WAAW,IAFE,SAAS,CAOrB;IAED;;;;OAIG;IACH,UAAM,UAAU,IAFH,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAoBD;;;;OAIG;IACH,UAAA,mBAAmB,IAFN,OAAO,wBAAwB,EAAE,oBAAoB,CAUjE;IAED;;;;;OAKG;IACH,UAAA,cAAc,IAHD,KAAK,CAKjB;CACF;eAEc,eAAe"}

package/dist/v1/libs/html/loader/formats/TinyFetchLoader.mjs

@@ -0,0 +1,197 @@
+/**
+ * @fileoverview Generic file loader for external resources.
+ * Uses the native `fetch` API by default, but accepts any implementation
+ * that follows the same contract: `(input, init) => Promise<Response>`.
+ */
+import TinyMediaLoader from '../TinyMediaLoader.mjs';
+/**
+ * The response body types supported by the loader.
+ * @typedef {'blob'|'arraybuffer'|'text'|'json'} FetchResponseType
+ */
+/**
+ * Describes the configuration accepted by the {@link TinyFetchLoader} constructor.
+ * @typedef {Object} FetchLoaderOptions
+ * @property {string} [src] - The file URL.
+ * @property {RequestInit} [init] - The fetch options (method, headers, body, credentials, mode, cache, redirect, referrer, referrerPolicy, integrity, keepalive).
+ * @property {typeof fetch} [fetch] - A custom fetch implementation.
+ * @property {FetchResponseType} [responseType] - The response body type (default `'blob'`).
+ * @property {number} [timeout] - Maximum time in milliseconds before the load is aborted.
+ * @property {boolean} [useHeadRequest] - Whether to perform a HEAD request before downloading.
+ * @property {BodyInit} [body] - The request body forwarded to the transport (ignored by `GET`/`HEAD`).
+ * @property {boolean} [progressive] - Whether to emit progress events (default `true`).
+ * @property {boolean} [mirror] - Whether concurrent loads of the same source share a single download (default `true`).
+ * @property {import('../utils/TinyMediaCache.mjs').default|null} [cache] - An optional shared memory cache.
+ */
+/**
+ * The signature of the function returned by {@link TinyFetchLoader#exportFetch}.
+ * @typedef {(input: string|URL|Request, init?: RequestInit) => Promise<Response>} TinyFetch
+ */
+/**
+ * Loads an arbitrary file through the native `fetch` API.
+ *
+ * The class does not create a DOM element. It reuses the state machine,
+ * progress tracker, cache and mirror registry of {@link TinyMediaLoader},
+ * and exposes the downloaded payload through {@link TinyFetchLoader#blob}
+ * and {@link TinyFetchLoader#data}.
+ * @extends {TinyMediaLoader<any>}
+ */
+class TinyFetchLoader extends TinyMediaLoader {
+    /** @type {RequestInit} */
+    #init;
+    /** @type {FetchResponseType} */
+    #responseType;
+    /** @type {Blob|null} */
+    #blob = null;
+    /** @type {Blob|ArrayBuffer|string|unknown|null} */
+    #data = null;
+    /** @type {FetchLoaderOptions} */
+    #options;
+    /**
+     * @param {FetchLoaderOptions} [options] - The loader configuration.
+     * @throws {TypeError} If `fetch` is not a function.
+     * @throws {TypeError} If `init` is not a plain object.
+     * @throws {RangeError} If `responseType` is not supported.
+     */
+    constructor(options = {}) {
+        if (options === null || typeof options !== 'object' || Array.isArray(options)) {
+            throw new TypeError('The "options" argument must be a plain object.');
+        }
+        super(options);
+        const { fetch: fetcher = globalThis.fetch.bind(globalThis), init = {}, responseType = 'blob', } = options;
+        if (typeof fetcher !== 'function') {
+            throw new TypeError('The "fetch" option must be a function.');
+        }
+        if (init === null || typeof init !== 'object' || Array.isArray(init)) {
+            throw new TypeError('The "init" option must be a plain object.');
+        }
+        if (!['blob', 'arraybuffer', 'text', 'json'].includes(responseType)) {
+            throw new RangeError('The "responseType" option must be one of: blob, arraybuffer, text, json.');
+        }
+        this._fetch = fetcher;
+        this._requestInit = init;
+        this.#init = init;
+        this.#responseType = responseType;
+        this.#options = { ...options, fetch: fetcher, init: { ...init }, responseType };
+    }
+    /**
+     * The downloaded file, or null before the load finishes.
+     * @returns {Blob|null} The raw payload.
+     */
+    get blob() {
+        return this.#blob;
+    }
+    /**
+     * The parsed payload, in the format requested by `responseType`.
+     * @returns {Blob|ArrayBuffer|string|unknown|null} The parsed payload.
+     */
+    get data() {
+        return this.#data;
+    }
+    /**
+     * The response body type requested at construction time.
+     * @returns {FetchResponseType} The response body type.
+     */
+    get responseType() {
+        return this.#responseType;
+    }
+    /**
+     * The fetch options forwarded to the transport.
+     * @returns {RequestInit} A defensive copy of the fetch options.
+     */
+    get init() {
+        return { ...this.#init };
+    }
+    /**
+     * Creates a new loader with the same configuration.
+     *
+     * The clone is fully independent: it has its own state machine, its own
+     * abort controller and its own `blob`/`data` slots. The shared `cache` and
+     * the custom `fetch` implementation are reused by reference, which is what
+     * makes {@link TinyFetchLoader#exportFetch} cheap.
+     * @param {FetchLoaderOptions} [overrides] - Values that override the cloned configuration.
+     * @returns {TinyFetchLoader} A new, independent loader.
+     * @throws {TypeError} If `overrides` is not a plain object.
+     */
+    clone(overrides = {}) {
+        if (overrides === null || typeof overrides !== 'object' || Array.isArray(overrides)) {
+            throw new TypeError('The "overrides" argument must be a plain object.');
+        }
+        const init = { ...this.#options.init, ...(overrides.init ?? {}) };
+        return new TinyFetchLoader({ ...this.#options, ...overrides, init });
+    }
+    /**
+     * Returns a `fetch`-compatible function backed by this loader.
+     * @returns {TinyFetch} A function with the same signature as `fetch`.
+     */
+    exportFetch() {
+        const self = this;
+        return async function tinyFetch(input, init) {
+            return self._fetch(input, init);
+        };
+    }
+    /**
+     * Downloads the file, consulting the shared cache first.
+     * @protected
+     * @returns {Promise<void>} Resolves once the payload is ready.
+     */
+    async _startLoad() {
+        const cached = this._acquireFromCache();
+        if (cached) {
+            this.emit('cachehit', cached);
+            this.#blob = cached.blob;
+            await this.#parse(cached.blob);
+            return;
+        }
+        const blob = await this._downloadStream(this.src);
+        this.#blob = blob;
+        this._setResourceSize(blob.size);
+        if (this.cache) {
+            this._cacheBlob(blob);
+        }
+        await this.#parse(blob);
+    }
+    /**
+     * Converts the raw blob into the format requested by `responseType`.
+     * @param {Blob} blob - The downloaded or cached payload.
+     * @returns {Promise<void>} Resolves once `data` is populated.
+     * @throws {SyntaxError} If `responseType` is `'json'` and the body is not valid JSON.
+     */
+    async #parse(blob) {
+        if (this.#responseType === 'arraybuffer') {
+            this.#data = await blob.arrayBuffer();
+        }
+        else if (this.#responseType === 'text') {
+            this.#data = await blob.text();
+        }
+        else if (this.#responseType === 'json') {
+            this.#data = JSON.parse(await blob.text());
+        }
+        else {
+            this.#data = blob;
+        }
+    }
+    /**
+     * Builds the metadata descriptor for the loaded file.
+     * @protected
+     * @returns {import('../TinyMediaLoader.mjs').MediaMetadataDetails} The file metadata.
+     */
+    _getMetadataDetails() {
+        return {
+            type: this.#blob?.type || 'application/octet-stream',
+            width: 0,
+            height: 0,
+            duration: 0,
+            size: this.#blob?.size ?? 0,
+        };
+    }
+    /**
+     * `TinyFetchLoader` does not render anything, so this method always throws.
+     * @protected
+     * @returns {never} This method never returns.
+     * @throws {Error} Always.
+     */
+    _createElement() {
+        throw new Error('TinyFetchLoader does not create a DOM element.');
+    }
+}
+export default TinyFetchLoader;