@loaders.gl/core 3.4.10 → 3.4.12

package/dist/lib/api/parse-sync.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSync = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const select_loader_1 = require("./select-loader");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const option_utils_1 = require("../loader-utils/option-utils");
-const get_data_1 = require("../loader-utils/get-data");
-const loader_context_1 = require("../loader-utils/loader-context");
-const resource_utils_1 = require("../utils/resource-utils");
-/**
- * Parses `data` synchronously using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
- */
-function parseSync(data, loaders, options, context) {
-    (0, loader_utils_1.assert)(!context || typeof context === 'object'); // parseSync no longer accepts final url
-    // Signature: parseSync(data, options)
-    // Uses registered loaders
-    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
-        context = undefined; // context not supported in short signature
-        options = loaders;
-        loaders = undefined;
-    }
-    options = options || {};
-    // Chooses a loader (and normalizes it)
-    // Also use any loaders in the context, new loaders take priority
-    const typedLoaders = loaders;
-    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
-    const loader = (0, select_loader_1.selectLoaderSync)(data, candidateLoaders, options);
-    // Note: if nothrow option was set, it is possible that no loader was found, if so just return null
-    if (!loader) {
-        return null;
-    }
-    // Normalize options
-    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders);
-    // Extract a url for auto detection
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    const parse = () => {
-        throw new Error('parseSync called parse (which is async');
-    };
-    context = (0, loader_context_1.getLoaderContext)({ url, parseSync, parse, loaders: loaders }, options, context || null);
-    return parseWithLoaderSync(loader, data, options, context);
-}
-exports.parseSync = parseSync;
-// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
-function parseWithLoaderSync(loader, data, options, context) {
-    data = (0, get_data_1.getArrayBufferOrStringFromDataSync)(data, loader, options);
-    if (loader.parseTextSync && typeof data === 'string') {
-        return loader.parseTextSync(data, options); // , context, loader);
-    }
-    if (loader.parseSync && data instanceof ArrayBuffer) {
-        return loader.parseSync(data, options, context); // , loader);
-    }
-    // TBD - If synchronous parser not available, return null
-    throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ''}`);
-}

package/dist/lib/api/parse.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
-const worker_utils_1 = require("@loaders.gl/worker-utils");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const is_type_1 = require("../../javascript-utils/is-type");
-const option_utils_1 = require("../loader-utils/option-utils");
-const get_data_1 = require("../loader-utils/get-data");
-const loader_context_1 = require("../loader-utils/loader-context");
-const resource_utils_1 = require("../utils/resource-utils");
-const select_loader_1 = require("./select-loader");
-/**
- * Parses `data` using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
- */
-async function parse(data, loaders, options, context) {
-    (0, worker_utils_1.assert)(!context || typeof context === 'object'); // parse no longer accepts final url
-    // Signature: parse(data, options, context | url)
-    // Uses registered loaders
-    if (loaders && !Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
-        context = undefined; // context not supported in short signature
-        options = loaders;
-        loaders = undefined;
-    }
-    data = await data; // Resolve any promise
-    options = options || {};
-    // Extract a url for auto detection
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    // Chooses a loader (and normalizes it)
-    // Also use any loaders in the context, new loaders take priority
-    const typedLoaders = loaders;
-    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
-    // todo hacky type cast
-    const loader = await (0, select_loader_1.selectLoader)(data, candidateLoaders, options);
-    // Note: if no loader was found, if so just return null
-    if (!loader) {
-        return null;
-    }
-    // Normalize options
-    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders, url);
-    // Get a context (if already present, will be unchanged)
-    context = (0, loader_context_1.getLoaderContext)({ url, parse, loaders: candidateLoaders }, options, context || null);
-    return await parseWithLoader(loader, data, options, context);
-}
-exports.parse = parse;
-// TODO: support progress and abort
-// TODO - should accept loader.parseAsyncIterator and concatenate.
-async function parseWithLoader(loader, data, options, context) {
-    (0, worker_utils_1.validateWorkerVersion)(loader);
-    if ((0, is_type_1.isResponse)(data)) {
-        // Serialize to support passing the response to web worker
-        const response = data;
-        const { ok, redirected, status, statusText, type, url } = response;
-        const headers = Object.fromEntries(response.headers.entries());
-        context.response = { headers, ok, redirected, status, statusText, type, url };
-    }
-    data = await (0, get_data_1.getArrayBufferOrStringFromData)(data, loader, options);
-    // First check for synchronous text parser, wrap results in promises
-    if (loader.parseTextSync && typeof data === 'string') {
-        options.dataType = 'text';
-        return loader.parseTextSync(data, options, context, loader);
-    }
-    // If we have a workerUrl and the loader can parse the given options efficiently in a worker
-    if ((0, loader_utils_1.canParseWithWorker)(loader, options)) {
-        return await (0, loader_utils_1.parseWithWorker)(loader, data, options, context, parse);
-    }
-    // Check for asynchronous parser
-    if (loader.parseText && typeof data === 'string') {
-        return await loader.parseText(data, options, context, loader);
-    }
-    if (loader.parse) {
-        return await loader.parse(data, options, context, loader);
-    }
-    // This should not happen, all sync loaders should also offer `parse` function
-    (0, worker_utils_1.assert)(!loader.parseSync);
-    // TBD - If asynchronous parser not available, return null
-    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
-}

package/dist/lib/api/register-loaders.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._unregisterLoaders = exports.getRegisteredLoaders = exports.registerLoaders = void 0;
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const option_utils_1 = require("../loader-utils/option-utils");
-// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability
-// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
-const getGlobalLoaderRegistry = () => {
-    const state = (0, option_utils_1.getGlobalLoaderState)();
-    state.loaderRegistry = state.loaderRegistry || [];
-    return state.loaderRegistry;
-};
-/** Register a list of global loaders */
-function registerLoaders(loaders) {
-    const loaderRegistry = getGlobalLoaderRegistry();
-    loaders = Array.isArray(loaders) ? loaders : [loaders];
-    for (const loader of loaders) {
-        const normalizedLoader = (0, normalize_loader_1.normalizeLoader)(loader);
-        if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
-            // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
-            loaderRegistry.unshift(normalizedLoader);
-        }
-    }
-}
-exports.registerLoaders = registerLoaders;
-function getRegisteredLoaders() {
-    return getGlobalLoaderRegistry();
-}
-exports.getRegisteredLoaders = getRegisteredLoaders;
-/** @deprecated For testing only  */
-function _unregisterLoaders() {
-    const state = (0, option_utils_1.getGlobalLoaderState)();
-    state.loaderRegistry = [];
-}
-exports._unregisterLoaders = _unregisterLoaders;

package/dist/lib/api/save.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.saveSync = exports.save = void 0;
-const encode_1 = require("./encode");
-const write_file_1 = require("../fetch/write-file");
-async function save(data, url, writer, options) {
-    const encodedData = await (0, encode_1.encode)(data, writer, options);
-    return await (0, write_file_1.writeFile)(url, encodedData);
-}
-exports.save = save;
-function saveSync(data, url, writer, options) {
-    const encodedData = (0, encode_1.encodeSync)(data, writer, options);
-    return (0, write_file_1.writeFileSync)(url, encodedData);
-}
-exports.saveSync = saveSync;

package/dist/lib/api/select-loader.js

@@ -1,253 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectLoaderSync = exports.selectLoader = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const log_1 = require("../utils/log");
-const resource_utils_1 = require("../utils/resource-utils");
-const register_loaders_1 = require("./register-loaders");
-const is_type_1 = require("../../javascript-utils/is-type");
-const url_utils_1 = require("../utils/url-utils");
-const EXT_PATTERN = /\.([^.]+)$/;
-// TODO - Need a variant that peeks at streams for parseInBatches
-// TODO - Detect multiple matching loaders? Use heuristics to grade matches?
-// TODO - Allow apps to pass context to disambiguate between multiple matches (e.g. multiple .json formats)?
-/**
- * Find a loader that matches file extension and/or initial file content
- * Search the loaders array argument for a loader that matches url extension or initial data
- * Returns: a normalized loader
- * @param data data to assist
- * @param loaders
- * @param options
- * @param context used internally, applications should not provide this parameter
- */
-async function selectLoader(data, loaders = [], options, context) {
-    if (!validHTTPResponse(data)) {
-        return null;
-    }
-    // First make a sync attempt, disabling exceptions
-    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
-    if (loader) {
-        return loader;
-    }
-    // For Blobs and Files, try to asynchronously read a small initial slice and test again with that
-    // to see if we can detect by initial content
-    if ((0, is_type_1.isBlob)(data)) {
-        data = await data.slice(0, 10).arrayBuffer();
-        loader = selectLoaderSync(data, loaders, options, context);
-    }
-    // no loader available
-    if (!loader && !options?.nothrow) {
-        throw new Error(getNoValidLoaderMessage(data));
-    }
-    return loader;
-}
-exports.selectLoader = selectLoader;
-/**
- * Find a loader that matches file extension and/or initial file content
- * Search the loaders array argument for a loader that matches url extension or initial data
- * Returns: a normalized loader
- * @param data data to assist
- * @param loaders
- * @param options
- * @param context used internally, applications should not provide this parameter
- */
-function selectLoaderSync(data, loaders = [], options, context) {
-    if (!validHTTPResponse(data)) {
-        return null;
-    }
-    // eslint-disable-next-line complexity
-    // if only a single loader was provided (not as array), force its use
-    // TODO - Should this behavior be kept and documented?
-    if (loaders && !Array.isArray(loaders)) {
-        // TODO - remove support for legacy loaders
-        return (0, normalize_loader_1.normalizeLoader)(loaders);
-    }
-    // Build list of candidate loaders that will be searched in order for a match
-    let candidateLoaders = [];
-    // First search supplied loaders
-    if (loaders) {
-        candidateLoaders = candidateLoaders.concat(loaders);
-    }
-    // Then fall back to registered loaders
-    if (!options?.ignoreRegisteredLoaders) {
-        candidateLoaders.push(...(0, register_loaders_1.getRegisteredLoaders)());
-    }
-    // TODO - remove support for legacy loaders
-    normalizeLoaders(candidateLoaders);
-    const loader = selectLoaderInternal(data, candidateLoaders, options, context);
-    // no loader available
-    if (!loader && !options?.nothrow) {
-        throw new Error(getNoValidLoaderMessage(data));
-    }
-    return loader;
-}
-exports.selectLoaderSync = selectLoaderSync;
-/** Implements loaders selection logic */
-// eslint-disable-next-line complexity
-function selectLoaderInternal(data, loaders, options, context) {
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    const type = (0, resource_utils_1.getResourceMIMEType)(data);
-    const testUrl = (0, url_utils_1.stripQueryString)(url) || context?.url;
-    let loader = null;
-    let reason = '';
-    // if options.mimeType is supplied, it takes precedence
-    if (options?.mimeType) {
-        loader = findLoaderByMIMEType(loaders, options?.mimeType);
-        reason = `match forced by supplied MIME type ${options?.mimeType}`;
-    }
-    // Look up loader by url
-    loader = loader || findLoaderByUrl(loaders, testUrl);
-    reason = reason || (loader ? `matched url ${testUrl}` : '');
-    // Look up loader by mime type
-    loader = loader || findLoaderByMIMEType(loaders, type);
-    reason = reason || (loader ? `matched MIME type ${type}` : '');
-    // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)
-    loader = loader || findLoaderByInitialBytes(loaders, data);
-    reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : '');
-    // Look up loader by fallback mime type
-    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-    reason = reason || (loader ? `matched fallback MIME type ${type}` : '');
-    if (reason) {
-        log_1.log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
-    }
-    return loader;
-}
-/** Check HTTP Response */
-function validHTTPResponse(data) {
-    // HANDLE HTTP status
-    if (data instanceof Response) {
-        // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile
-        if (data.status === 204) {
-            return false;
-        }
-    }
-    return true;
-}
-/** Generate a helpful message to help explain why loader selection failed. */
-function getNoValidLoaderMessage(data) {
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    const type = (0, resource_utils_1.getResourceMIMEType)(data);
-    let message = 'No valid loader found (';
-    message += url ? `${loader_utils_1.path.filename(url)}, ` : 'no url provided, ';
-    message += `MIME type: ${type ? `"${type}"` : 'not provided'}, `;
-    // First characters are only accessible when called on data (string or arrayBuffer).
-    const firstCharacters = data ? getFirstCharacters(data) : '';
-    message += firstCharacters ? ` first bytes: "${firstCharacters}"` : 'first bytes: not available';
-    message += ')';
-    return message;
-}
-function normalizeLoaders(loaders) {
-    for (const loader of loaders) {
-        (0, normalize_loader_1.normalizeLoader)(loader);
-    }
-}
-// TODO - Would be nice to support http://example.com/file.glb?parameter=1
-// E.g: x = new URL('http://example.com/file.glb?load=1'; x.pathname
-function findLoaderByUrl(loaders, url) {
-    // Get extension
-    const match = url && EXT_PATTERN.exec(url);
-    const extension = match && match[1];
-    return extension ? findLoaderByExtension(loaders, extension) : null;
-}
-function findLoaderByExtension(loaders, extension) {
-    extension = extension.toLowerCase();
-    for (const loader of loaders) {
-        for (const loaderExtension of loader.extensions) {
-            if (loaderExtension.toLowerCase() === extension) {
-                return loader;
-            }
-        }
-    }
-    return null;
-}
-function findLoaderByMIMEType(loaders, mimeType) {
-    for (const loader of loaders) {
-        if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
-            return loader;
-        }
-        // Support referring to loaders using the "unregistered tree"
-        // https://en.wikipedia.org/wiki/Media_type#Unregistered_tree
-        if (mimeType === `application/x.${loader.id}`) {
-            return loader;
-        }
-    }
-    return null;
-}
-function findLoaderByInitialBytes(loaders, data) {
-    if (!data) {
-        return null;
-    }
-    for (const loader of loaders) {
-        if (typeof data === 'string') {
-            if (testDataAgainstText(data, loader)) {
-                return loader;
-            }
-        }
-        else if (ArrayBuffer.isView(data)) {
-            // Typed Arrays can have offsets into underlying buffer
-            if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
-                return loader;
-            }
-        }
-        else if (data instanceof ArrayBuffer) {
-            const byteOffset = 0;
-            if (testDataAgainstBinary(data, byteOffset, loader)) {
-                return loader;
-            }
-        }
-        // TODO Handle streaming case (requires creating a new AsyncIterator)
-    }
-    return null;
-}
-function testDataAgainstText(data, loader) {
-    if (loader.testText) {
-        return loader.testText(data);
-    }
-    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-    return tests.some((test) => data.startsWith(test));
-}
-function testDataAgainstBinary(data, byteOffset, loader) {
-    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-    return tests.some((test) => testBinary(data, byteOffset, loader, test));
-}
-function testBinary(data, byteOffset, loader, test) {
-    if (test instanceof ArrayBuffer) {
-        return (0, loader_utils_1.compareArrayBuffers)(test, data, test.byteLength);
-    }
-    switch (typeof test) {
-        case 'function':
-            return test(data, loader);
-        case 'string':
-            // Magic bytes check: If `test` is a string, check if binary data starts with that strings
-            const magic = getMagicString(data, byteOffset, test.length);
-            return test === magic;
-        default:
-            return false;
-    }
-}
-function getFirstCharacters(data, length = 5) {
-    if (typeof data === 'string') {
-        return data.slice(0, length);
-    }
-    else if (ArrayBuffer.isView(data)) {
-        // Typed Arrays can have offsets into underlying buffer
-        return getMagicString(data.buffer, data.byteOffset, length);
-    }
-    else if (data instanceof ArrayBuffer) {
-        const byteOffset = 0;
-        return getMagicString(data, byteOffset, length);
-    }
-    return '';
-}
-function getMagicString(arrayBuffer, byteOffset, length) {
-    if (arrayBuffer.byteLength < byteOffset + length) {
-        return '';
-    }
-    const dataView = new DataView(arrayBuffer);
-    let magic = '';
-    for (let i = 0; i < length; i++) {
-        magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
-    }
-    return magic;
-}

package/dist/lib/common.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/fetch/fetch-error-message.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessageFromResponse = exports.getErrorMessageFromResponseSync = void 0;
-function getErrorMessageFromResponseSync(response) {
-    return `Failed to fetch resource ${response.url}(${response.status}): ${response.statusText} `;
-}
-exports.getErrorMessageFromResponseSync = getErrorMessageFromResponseSync;
-async function getErrorMessageFromResponse(response) {
-    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
-    try {
-        const contentType = response.headers.get('Content-Type') || '';
-        if (contentType.includes('application/json')) {
-            message += await response.text();
-        }
-        else {
-            message += response.statusText;
-        }
-    }
-    catch (error) {
-        // eslint forbids return in finally statement
-        return message;
-    }
-    return message;
-}
-exports.getErrorMessageFromResponse = getErrorMessageFromResponse;

package/dist/lib/fetch/fetch-file.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchFile = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const response_utils_1 = require("../utils/response-utils");
-// import {getErrorMessageFromResponse} from './fetch-error-message';
-/**
- * fetch compatible function
- * Reads file data from:
- * - http/http urls
- * - data urls
- * - File/Blob objects
- * Leverages `@loaders.gl/polyfills` for Node.js support
- * Respects pathPrefix and file aliases
- */
-async function fetchFile(url, options) {
-    if (typeof url === 'string') {
-        url = (0, loader_utils_1.resolvePath)(url);
-        let fetchOptions = options;
-        if (options?.fetch && typeof options?.fetch !== 'function') {
-            fetchOptions = options.fetch;
-        }
-        return await fetch(url, fetchOptions);
-    }
-    return await (0, response_utils_1.makeResponse)(url);
-}
-exports.fetchFile = fetchFile;

package/dist/lib/fetch/read-array-buffer.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readBlob = exports.readArrayBuffer = void 0;
-//
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-/**
- * Reads a chunk from a random access file
- * @param file
- * @param start
- * @param length
- * @returns
- */
-async function readArrayBuffer(file, start, length) {
-    if (typeof file === 'number') {
-        return await loader_utils_1.fs._readToArrayBuffer(file, start, length);
-    }
-    // TODO - we can do better for ArrayBuffer and string
-    if (!(file instanceof Blob)) {
-        file = new Blob([file]);
-    }
-    const slice = file.slice(start, start + length);
-    return await readBlob(slice);
-}
-exports.readArrayBuffer = readArrayBuffer;
-/**
- * Read a slice of a Blob or File, without loading the entire file into memory
- * The trick when reading File objects is to read successive "slices" of the File
- * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
- * Actually reading from file happens in `readAsArrayBuffer`
- * @param blob to read
- */
-async function readBlob(blob) {
-    return await new Promise((resolve, reject) => {
-        const fileReader = new FileReader();
-        fileReader.onload = (event) => resolve(event?.target?.result);
-        // TODO - reject with a proper Error
-        fileReader.onerror = (error) => reject(error);
-        fileReader.readAsArrayBuffer(blob);
-    });
-}
-exports.readBlob = readBlob;

package/dist/lib/fetch/read-file.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readFileSync = void 0;
-// File read
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const loader_utils_2 = require("@loaders.gl/loader-utils");
-// TODO - this is not tested
-// const isDataURL = (url) => url.startsWith('data:');
-/**
- * In a few cases (data URIs, node.js) "files" can be read synchronously
- */
-function readFileSync(url, options = {}) {
-    url = (0, loader_utils_1.resolvePath)(url);
-    // Only support this if we can also support sync data URL decoding in browser
-    // if (isDataURL(url)) {
-    //   return decodeDataUri(url);
-    // }
-    if (!loader_utils_1.isBrowser) {
-        const buffer = loader_utils_1.fs.readFileSync(url, options);
-        return typeof buffer !== 'string' ? (0, loader_utils_1.toArrayBuffer)(buffer) : buffer;
-    }
-    // @ts-ignore
-    if (!options.nothrow) {
-        // throw new Error('Cant load URI synchronously');
-        (0, loader_utils_2.assert)(false);
-    }
-    return null;
-}
-exports.readFileSync = readFileSync;

package/dist/lib/fetch/write-file.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileSync = exports.writeFile = void 0;
-// file write
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const loader_utils_2 = require("@loaders.gl/loader-utils");
-async function writeFile(filePath, arrayBufferOrString, options) {
-    filePath = (0, loader_utils_1.resolvePath)(filePath);
-    if (!loader_utils_1.isBrowser) {
-        await loader_utils_2.fs.writeFile(filePath, (0, loader_utils_2.toBuffer)(arrayBufferOrString), { flag: 'w' });
-    }
-    (0, loader_utils_1.assert)(false);
-}
-exports.writeFile = writeFile;
-function writeFileSync(filePath, arrayBufferOrString, options) {
-    filePath = (0, loader_utils_1.resolvePath)(filePath);
-    if (!loader_utils_1.isBrowser) {
-        loader_utils_2.fs.writeFileSync(filePath, (0, loader_utils_2.toBuffer)(arrayBufferOrString), { flag: 'w' });
-    }
-    (0, loader_utils_1.assert)(false);
-}
-exports.writeFileSync = writeFileSync;