@atlaspack/utils 2.14.5-canary.49 → 2.14.5-canary.490

package/lib/schema.js

@@ -0,0 +1,352 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.fuzzySearch = fuzzySearch;
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function levenshtein() {
+  const data = _interopRequireWildcard(require("fastest-levenshtein"));
+  levenshtein = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function validateSchema(schema, data) {
+  function walk(schemaAncestors, dataNode, dataPath) {
+    let [schemaNode] = schemaAncestors;
+    if ('type' in schemaNode && schemaNode.type) {
+      let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
+      if (schemaNode.type !== type) {
+        return {
+          type: 'type',
+          dataType: 'value',
+          dataPath,
+          expectedTypes: [schemaNode.type],
+          ancestors: schemaAncestors,
+          prettyType: '__type' in schemaNode ? schemaNode.__type : undefined
+        };
+      } else {
+        switch (schemaNode.type) {
+          case 'array':
+            {
+              if ('items' in schemaNode && schemaNode.items && Array.isArray(dataNode)) {
+                let results = [];
+                for (let i = 0; i < dataNode.length; i++) {
+                  let result = walk([schemaNode.items].concat(schemaAncestors), dataNode[i], dataPath + '/' + i);
+                  if (result) results.push(result);
+                }
+                if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
+              }
+              break;
+            }
+          case 'string':
+            {
+              if (typeof dataNode === 'string') {
+                let value = dataNode;
+                if ('enum' in schemaNode && schemaNode.enum) {
+                  if (!schemaNode.enum.includes(value)) {
+                    return {
+                      type: 'enum',
+                      dataType: 'value',
+                      dataPath,
+                      expectedValues: schemaNode.enum,
+                      actualValue: value,
+                      ancestors: schemaAncestors
+                    };
+                  }
+                } else if ('__validate' in schemaNode && schemaNode.__validate) {
+                  let validationError = schemaNode.__validate(value);
+                  if (typeof validationError == 'string') {
+                    return {
+                      type: 'other',
+                      dataType: 'value',
+                      dataPath,
+                      message: validationError,
+                      actualValue: value,
+                      ancestors: schemaAncestors
+                    };
+                  }
+                }
+              }
+              break;
+            }
+          case 'number':
+            {
+              if (typeof dataNode === 'number') {
+                let value = dataNode;
+                if ('enum' in schemaNode && schemaNode.enum) {
+                  if (!schemaNode.enum.includes(value)) {
+                    return {
+                      type: 'enum',
+                      dataType: 'value',
+                      dataPath,
+                      expectedValues: schemaNode.enum,
+                      actualValue: value,
+                      ancestors: schemaAncestors
+                    };
+                  }
+                }
+              }
+              break;
+            }
+          case 'object':
+            {
+              if (typeof dataNode === 'object' && dataNode !== null && !Array.isArray(dataNode)) {
+                let results = [];
+                let invalidProps;
+                if ('__forbiddenProperties' in schemaNode && schemaNode.__forbiddenProperties) {
+                  let keys = Object.keys(dataNode);
+                  invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
+                  results.push(...invalidProps.map(k => ({
+                    type: 'forbidden-prop',
+                    dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
+                    dataType: 'key',
+                    prop: k,
+                    expectedProps: Object.keys(schemaNode.properties),
+                    actualProps: keys,
+                    ancestors: schemaAncestors
+                  })));
+                }
+                if ('required' in schemaNode && schemaNode.required) {
+                  let keys = Object.keys(dataNode);
+                  let missingKeys = schemaNode.required.filter(val => !keys.includes(val));
+                  results.push(...missingKeys.map(k => ({
+                    type: 'missing-prop',
+                    dataPath,
+                    dataType: 'value',
+                    prop: k,
+                    expectedProps: schemaNode.required,
+                    actualProps: keys,
+                    ancestors: schemaAncestors
+                  })));
+                }
+                if ('properties' in schemaNode && schemaNode.properties) {
+                  let {
+                    additionalProperties = true
+                  } = schemaNode;
+                  for (let k in dataNode) {
+                    if (invalidProps && invalidProps.includes(k)) {
+                      // Don't check type on forbidden props
+                      continue;
+                    } else if (k in schemaNode.properties) {
+                      let result = walk([schemaNode.properties[k]].concat(schemaAncestors), dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
+                      if (result) results.push(result);
+                    } else {
+                      if (typeof additionalProperties === 'boolean') {
+                        if (!additionalProperties) {
+                          results.push({
+                            type: 'enum',
+                            dataType: 'key',
+                            dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
+                            expectedValues: Object.keys(schemaNode.properties).filter(p => !(p in dataNode)),
+                            actualValue: k,
+                            ancestors: schemaAncestors,
+                            prettyType: schemaNode.__type
+                          });
+                        }
+                      } else {
+                        let result = walk([additionalProperties].concat(schemaAncestors), dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
+                        if (result) results.push(result);
+                      }
+                    }
+                  }
+                }
+                if (results.length) return results.reduce((acc, v) => acc.concat(v), []);
+              }
+              break;
+            }
+          case 'boolean':
+            // NOOP, type was checked already
+            break;
+          default:
+            throw new Error(`Unimplemented schema type ${type}?`);
+        }
+      }
+    } else {
+      if ('enum' in schemaNode && schemaNode.enum && !schemaNode.enum.includes(dataNode)) {
+        return {
+          type: 'enum',
+          dataType: 'value',
+          dataPath: dataPath,
+          expectedValues: schemaNode.enum,
+          actualValue: schemaNode,
+          ancestors: schemaAncestors
+        };
+      }
+      if ('oneOf' in schemaNode || 'allOf' in schemaNode) {
+        let list = 'oneOf' in schemaNode ? schemaNode.oneOf : 'allOf' in schemaNode ? schemaNode.allOf : [];
+        let results = [];
+        for (let f of list) {
+          let result = walk([f].concat(schemaAncestors), dataNode, dataPath);
+          if (result) results.push(result);
+        }
+        if ('oneOf' in schemaNode ? results.length == schemaNode.oneOf.length : results.length > 0) {
+          // return the result with more values / longer key
+          results.sort((a, b) => Array.isArray(a) || Array.isArray(b) ? Array.isArray(a) && !Array.isArray(b) ? -1 : !Array.isArray(a) && Array.isArray(b) ? 1 : Array.isArray(a) && Array.isArray(b) ? b.length - a.length : 0 : b.dataPath.length - a.dataPath.length);
+          return results[0];
+        }
+      } else if ('not' in schemaNode && schemaNode.not) {
+        let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
+        if (!result || Array.isArray(result) && result.length == 0) {
+          return {
+            type: 'other',
+            dataPath,
+            dataType: null,
+            message: schemaNode.__message,
+            actualValue: dataNode,
+            ancestors: schemaAncestors
+          };
+        }
+      }
+    }
+    return undefined;
+  }
+  let result = walk([schema], data, '');
+  return Array.isArray(result) ? result : result ? [result] : [];
+}
+var _default = exports.default = validateSchema;
+function fuzzySearch(expectedValues, actualValue) {
+  let result = expectedValues.map(exp => [exp, levenshtein().distance(exp, actualValue)]).filter(
+  // Remove if more than half of the string would need to be changed
+  ([, d]) => d * 2 < actualValue.length);
+  result.sort(([, a], [, b]) => a - b);
+  return result.map(([v]) => v);
+}
+validateSchema.diagnostic = function (schema, data, origin, message) {
+  if (!('map' in data) && !('source' in data || 'data' in data)) {
+    throw new Error('At least one of data.source, data.data, or data.map must be defined!');
+  }
+  let loadedSource;
+  function loadSource(loader) {
+    if (loadedSource !== undefined) {
+      return loadedSource;
+    } else if (typeof loader === 'function') {
+      loadedSource = loader();
+      return loadedSource;
+    } else if (typeof loader === 'string') {
+      loadedSource = loader;
+      return loadedSource;
+    }
+    return loadedSource;
+  }
+  let object;
+  if ('map' in data && data.map) {
+    object = data.map.data;
+  } else if ('data' in data && data.data !== undefined) {
+    object = data.data;
+  } else if ('source' in data && data.source) {
+    object = JSON.parse(loadSource(data.source) || '');
+  } else {
+    throw new Error('Unable to get object from data');
+  }
+  let errors = validateSchema(schema, object);
+  if (errors.length) {
+    let keys = errors.map(e => {
+      let message;
+      if (e.type === 'enum') {
+        let {
+          actualValue
+        } = e;
+        let expectedValues = e.expectedValues.map(String);
+        let likely = actualValue != null ? fuzzySearch(expectedValues, String(actualValue)) : [];
+        if (likely.length > 0) {
+          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
+        } else if (expectedValues.length > 0) {
+          message = `Possible values: ${expectedValues.map(v => JSON.stringify(v)).join(', ')}`;
+        } else {
+          message = 'Unexpected value';
+        }
+      } else if (e.type === 'forbidden-prop') {
+        let {
+          prop,
+          expectedProps,
+          actualProps
+        } = e;
+        let likely = fuzzySearch(expectedProps, prop).filter(v => !actualProps.includes(v));
+        if (likely.length > 0) {
+          message = `Did you mean ${likely.map(v => JSON.stringify(v)).join(', ')}?`;
+        } else {
+          message = 'Unexpected property';
+        }
+      } else if (e.type === 'missing-prop') {
+        let {
+          prop,
+          actualProps
+        } = e;
+        let likely = fuzzySearch(actualProps, prop);
+        if (likely.length > 0) {
+          message = `Did you mean ${JSON.stringify(prop)}?`;
+          e.dataPath += '/' + likely[0];
+          e.dataType = 'key';
+        } else {
+          message = `Missing property ${prop}`;
+        }
+      } else if (e.type === 'type') {
+        if (e.prettyType != null) {
+          message = `Expected ${e.prettyType}`;
+        } else {
+          message = `Expected type ${e.expectedTypes.join(', ')}`;
+        }
+      } else {
+        message = e.message;
+      }
+      return {
+        key: e.dataPath,
+        type: e.dataType,
+        message
+      };
+    });
+    let map, code;
+    if ('map' in data && data.map) {
+      map = data.map;
+      code = loadSource(data.source) ?? '';
+    } else {
+      if ('source' in data && data.source) {
+        map = loadSource(data.source) ?? '';
+      } else if ('data' in data && data.data !== undefined) {
+        map = JSON.stringify((0, _nullthrows().default)(data.data), null, '\t');
+      } else {
+        map = '';
+      }
+      code = map;
+    }
+    let codeFrames = [{
+      filePath: data.filePath ?? undefined,
+      language: 'json',
+      code: code ?? '',
+      codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(map, keys.map(({
+        key,
+        type,
+        message
+      }) => ({
+        key: (data.prependKey ?? '') + key,
+        type: type,
+        message: message != null ? (0, _diagnostic().escapeMarkdown)(message) : message
+      })))
+    }];
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: message,
+        origin,
+        codeFrames
+      }
+    });
+  }
+};

package/lib/shared-buffer.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SharedBuffer = void 0;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
+let SharedBuffer = exports.SharedBuffer = void 0;
+
+// @ts-expect-error process.browser is a browser-specific property
+if (process.browser) {
+  exports.SharedBuffer = SharedBuffer = ArrayBuffer;
+  // Safari has removed the constructor
+  if (typeof SharedArrayBuffer !== 'undefined') {
+    let channel = new MessageChannel();
+    try {
+      // Firefox might throw when sending the Buffer over a MessagePort
+      channel.port1.postMessage(new SharedArrayBuffer(0));
+      exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+    } catch (_) {
+      // NOOP
+    }
+    channel.port1.close();
+    channel.port2.close();
+  }
+} else {
+  exports.SharedBuffer = SharedBuffer = SharedArrayBuffer;
+}

package/lib/sourcemap.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SOURCEMAP_RE = exports.SOURCEMAP_EXTENSIONS = void 0;
+exports.loadSourceMap = loadSourceMap;
+exports.loadSourceMapUrl = loadSourceMapUrl;
+exports.matchSourceMappingURL = matchSourceMappingURL;
+exports.remapSourceLocation = remapSourceLocation;
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _path2 = require("./path");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const SOURCEMAP_RE = exports.SOURCEMAP_RE = /(?:\/\*|\/\/)\s*[@#]\s*sourceMappingURL\s*=\s*([^\s*]+)(?:\s*\*\/)?\s*$/;
+const DATA_URL_RE = /^data:[^;]+(?:;charset=[^;]+)?;base64,(.*)/;
+const SOURCEMAP_EXTENSIONS = exports.SOURCEMAP_EXTENSIONS = new Set(['css', 'es', 'es6', 'js', 'jsx', 'mjs', 'ts', 'tsx']);
+function matchSourceMappingURL(contents) {
+  return contents.match(SOURCEMAP_RE);
+}
+async function loadSourceMapUrl(fs, filename, contents) {
+  let match = matchSourceMappingURL(contents);
+  if (match) {
+    let url = match[1].trim();
+    let dataURLMatch = url.match(DATA_URL_RE);
+    let mapFilePath;
+    if (dataURLMatch) {
+      mapFilePath = filename;
+    } else {
+      mapFilePath = url.replace(/^file:\/\//, '');
+      mapFilePath = (0, _path2.isAbsolute)(mapFilePath) ? mapFilePath : _path().default.join(_path().default.dirname(filename), mapFilePath);
+    }
+    return {
+      url,
+      filename: mapFilePath,
+      map: JSON.parse(dataURLMatch ? Buffer.from(dataURLMatch[1], 'base64').toString() : await fs.readFile(mapFilePath, 'utf8'))
+    };
+  }
+}
+async function loadSourceMap(filename, contents, options) {
+  let foundMap = await loadSourceMapUrl(options.fs, filename, contents);
+  if (foundMap) {
+    let mapSourceRoot = _path().default.dirname(filename);
+    if (foundMap.map.sourceRoot && !(0, _path2.normalizeSeparators)(foundMap.map.sourceRoot).startsWith('/')) {
+      mapSourceRoot = _path().default.join(mapSourceRoot, foundMap.map.sourceRoot);
+    }
+    let sourcemapInstance = new (_sourceMap().default)(options.projectRoot);
+    sourcemapInstance.addVLQMap({
+      ...foundMap.map,
+      sources: foundMap.map.sources.map(s => {
+        return _path().default.join(mapSourceRoot, s);
+      })
+    });
+    return sourcemapInstance;
+  }
+}
+function remapSourceLocation(loc, originalMap, projectRoot) {
+  let {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  } = loc;
+  let lineDiff = endLine - startLine;
+  let colDiff = endCol - startCol;
+  let start = originalMap.findClosestMapping(startLine, startCol - 1);
+  let end = originalMap.findClosestMapping(endLine, endCol - 1);
+  if (start !== null && start !== void 0 && start.original) {
+    if (start.source) {
+      if ((0, _featureFlags().getFeatureFlag)('symbolLocationFix') && !_path().default.isAbsolute(start.source)) {
+        filePath = _path().default.join(projectRoot, start.source);
+      } else {
+        filePath = start.source;
+      }
+    }
+    ({
+      line: startLine,
+      column: startCol
+    } = start.original);
+    startCol++; // source map columns are 0-based
+  }
+  if (end !== null && end !== void 0 && end.original) {
+    ({
+      line: endLine,
+      column: endCol
+    } = end.original);
+    endCol++; // source map columns are 0-based
+
+    if (endLine < startLine) {
+      endLine = startLine;
+      endCol = startCol;
+    } else if (endLine === startLine && endCol < startCol && lineDiff === 0) {
+      endCol = startCol + colDiff;
+    } else if (endLine === startLine && startCol === endCol && lineDiff === 0) {
+      // Prevent 0-length ranges
+      endCol = startCol + 1;
+    }
+  } else {
+    endLine = startLine;
+    endCol = startCol;
+  }
+  return {
+    filePath,
+    start: {
+      line: startLine,
+      column: startCol
+    },
+    end: {
+      line: endLine,
+      column: endCol
+    }
+  };
+}

package/lib/stream.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.blobToStream = blobToStream;
+exports.bufferStream = bufferStream;
+exports.fallbackStream = fallbackStream;
+exports.measureStreamLength = measureStreamLength;
+exports.readableFromStringOrBuffer = readableFromStringOrBuffer;
+exports.streamFromPromise = streamFromPromise;
+function _stream() {
+  const data = require("stream");
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function measureStreamLength(stream) {
+  return new Promise((resolve, reject) => {
+    let length = 0;
+    stream.on('data', chunk => {
+      length += chunk;
+    });
+    stream.on('end', () => resolve(length));
+    stream.on('error', reject);
+  });
+}
+function readableFromStringOrBuffer(str) {
+  // https://stackoverflow.com/questions/12755997/how-to-create-streams-from-string-in-node-js
+  const stream = new (_stream().Readable)();
+  stream.push(str);
+  stream.push(null);
+  return stream;
+}
+function bufferStream(stream) {
+  return new Promise((resolve, reject) => {
+    let buf = Buffer.from([]);
+    stream.on('data', data => {
+      buf = Buffer.concat([buf, data]);
+    });
+    stream.on('end', () => {
+      resolve(buf);
+    });
+    stream.on('error', reject);
+  });
+}
+function blobToStream(blob) {
+  if (blob instanceof _stream().Readable) {
+    return blob;
+  }
+  return readableFromStringOrBuffer(blob);
+}
+function streamFromPromise(promise) {
+  const stream = new (_stream().PassThrough)();
+  promise.then(blob => {
+    if (blob instanceof _stream().Readable) {
+      blob.pipe(stream);
+    } else {
+      stream.end(blob);
+    }
+  });
+  return stream;
+}
+function fallbackStream(stream, fallback) {
+  const res = new (_stream().PassThrough)();
+  stream.on('error', err => {
+    if (err.code === 'ENOENT') {
+      fallback().pipe(res);
+    } else {
+      res.emit('error', err);
+    }
+  });
+  stream.pipe(res);
+  return res;
+}

package/lib/throttle.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = throttle;
+function throttle(fn, delay) {
+  let lastCalled;
+  return function throttled(...args) {
+    if (lastCalled == null || lastCalled + delay <= Date.now()) {
+      fn.call(this, ...args);
+      lastCalled = Date.now();
+    }
+  };
+}

package/lib/types/DefaultMap.d.ts

@@ -0,0 +1,13 @@
+export declare class DefaultMap<K, V> extends Map<K, V> {
+    _getDefault: (arg1: K) => V;
+    constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>);
+    get(key: K): V;
+}
+interface Key {
+}
+export declare class DefaultWeakMap<K extends Key, V> extends WeakMap<K, V> {
+    _getDefault: (arg1: K) => V;
+    constructor(getDefault: (arg1: K) => V, entries?: Iterable<[K, V]>);
+    get(key: K): V;
+}
+export {};

package/lib/types/Deferred.d.ts

@@ -0,0 +1,8 @@
+export type Deferred<T> = {
+    resolve(arg1: T): void;
+    reject(arg1: unknown): void;
+};
+export declare function makeDeferredWithPromise<T>(): {
+    deferred: Deferred<T>;
+    promise: Promise<T>;
+};

package/lib/types/PromiseQueue.d.ts

@@ -0,0 +1,25 @@
+import { type Deferred } from './Deferred';
+type PromiseQueueOpts = {
+    maxConcurrent: number;
+};
+export default class PromiseQueue<T> {
+    _deferred: Deferred<Array<T>> | null | undefined;
+    _maxConcurrent: number;
+    _numRunning: number;
+    _queue: Array<() => Promise<void>>;
+    _runPromise: Promise<Array<T>> | null | undefined;
+    _error: unknown;
+    _count: number;
+    _results: Array<T>;
+    _addSubscriptions: Set<() => void>;
+    constructor(opts?: PromiseQueueOpts);
+    getNumWaiting(): number;
+    add(fn: () => Promise<T>): void;
+    subscribeToAdd(fn: () => void): () => void;
+    run(): Promise<Array<T>>;
+    _next(): Promise<void>;
+    _runFn(fn: () => unknown): Promise<void>;
+    _resetState(): void;
+    _done(): void;
+}
+export {};

package/lib/types/TapStream.d.ts

@@ -0,0 +1,6 @@
+import { Transform } from 'stream';
+export default class TapStream extends Transform {
+    _tap: (arg1: Buffer) => unknown;
+    constructor(tap: (arg1: Buffer) => unknown, options: unknown);
+    _transform(chunk: Buffer | string, encoding: string, callback: (err?: Error | null | undefined, chunk?: Buffer | string) => unknown): void;
+}

package/lib/types/alternatives.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystem } from '@atlaspack/types-internal';
+export declare function findAlternativeNodeModules(fs: FileSystem, moduleName: string, dir: string): Promise<Array<string>>;
+export declare function findAlternativeFiles(fs: FileSystem, fileSpecifier: string, dir: string, projectRoot: string, leadingDotSlash?: boolean, includeDirectories?: boolean, includeExtension?: boolean): Promise<Array<string>>;

package/lib/types/ansi-html.d.ts

@@ -0,0 +1 @@
+export declare function ansiHtml(ansi: string): string;

package/lib/types/blob.d.ts

@@ -0,0 +1,4 @@
+import type { Blob } from '@atlaspack/types-internal';
+import { Buffer } from 'buffer';
+export declare function blobToBuffer(blob: Blob): Promise<Buffer>;
+export declare function blobToString(blob: Blob): Promise<string>;

package/lib/types/bundle-url.d.ts

@@ -0,0 +1,4 @@
+declare function getBundleURLCached(): string;
+export declare function getBaseURL(url?: string | null): string;
+export declare const getBundleURL: typeof getBundleURLCached;
+export {};