@rsdoctor/utils 1.1.10 → 1.2.0-beta.1

package/dist/cjs/common/graph/assets.js

@@ -1,348 +1,314 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var assets_exports = {};
-__export(assets_exports, {
-  diffAssetsByExtensions: () => diffAssetsByExtensions,
-  diffSize: () => diffSize,
-  extname: () => extname,
-  filterAssets: () => filterAssets,
-  filterAssetsByExtensions: () => filterAssetsByExtensions,
-  formatAssetName: () => formatAssetName,
-  getAllBundleData: () => getAllBundleData,
-  getAssetDetails: () => getAssetDetails,
-  getAssetsDiffResult: () => getAssetsDiffResult,
-  getAssetsSizeInfo: () => getAssetsSizeInfo,
-  getAssetsSummary: () => getAssetsSummary,
-  getInitialAssetsSizeInfo: () => getInitialAssetsSizeInfo,
-  isAssetMatchExtension: () => isAssetMatchExtension,
-  isAssetMatchExtensions: () => isAssetMatchExtensions,
-  isInitialAsset: () => isInitialAsset
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    extname: ()=>extname,
+    getAssetDetails: ()=>getAssetDetails,
+    diffSize: ()=>diffSize,
+    diffAssetsByExtensions: ()=>diffAssetsByExtensions,
+    filterAssets: ()=>filterAssets,
+    isInitialAsset: ()=>isInitialAsset,
+    isAssetMatchExtensions: ()=>isAssetMatchExtensions,
+    getAssetsSizeInfo: ()=>getAssetsSizeInfo,
+    getAssetsDiffResult: ()=>getAssetsDiffResult,
+    getInitialAssetsSizeInfo: ()=>getInitialAssetsSizeInfo,
+    filterAssetsByExtensions: ()=>filterAssetsByExtensions,
+    isAssetMatchExtension: ()=>isAssetMatchExtension,
+    formatAssetName: ()=>formatAssetName,
+    getAssetsSummary: ()=>getAssetsSummary,
+    getAllBundleData: ()=>getAllBundleData
 });
-module.exports = __toCommonJS(assets_exports);
-var import_types = require("@rsdoctor/types");
-var import_chunk = require("./chunk");
-var import_modules = require("./modules");
-const EXT = "js|css|html";
+const types_namespaceObject = require("@rsdoctor/types");
+const external_chunk_js_namespaceObject = require("./chunk.js");
+const external_modules_js_namespaceObject = require("./modules.js");
+const EXT = 'js|css|html';
 const hashPattern = /[a-z|A-Z|0-9]{4,32}/;
 const hashSeparatorPattern = /[-|.]/;
 const fileExtensionPattern = /(?:\.[a-z｜A-Z|0-9]{2,}){1,}/;
-const filenamePattern = new RegExp(
-  `(.*)${hashSeparatorPattern.source}${hashPattern.source}(${fileExtensionPattern.source})$`
-);
+const filenamePattern = new RegExp(`(.*)${hashSeparatorPattern.source}${hashPattern.source}(${fileExtensionPattern.source})$`);
 function formatAssetName(assetName, fileConfig) {
-  const splitFilesList = fileConfig?.split(".");
-  let outputFileTailName = "";
-  let unHashedFileName = assetName;
-  if (splitFilesList?.length && splitFilesList.length >= 3 && splitFilesList[splitFilesList.length - 2]?.indexOf("[") < 0 && EXT.indexOf(splitFilesList[splitFilesList.length - 1]) > -1) {
-    outputFileTailName = splitFilesList[splitFilesList.length - 2];
-    const _regPattern = /(.*)(\.[a-f0-9]{4,32})([^.]*.[^.]+){2,}/g;
-    unHashedFileName = assetName.replace(_regPattern, "$1");
-    return `${unHashedFileName}.${outputFileTailName}.${assetName.substring(
-      assetName.lastIndexOf(".") + 1
-    )}`;
-  }
-  return assetName.replace(filenamePattern, "$1$2");
+    var _splitFilesList_;
+    const splitFilesList = null == fileConfig ? void 0 : fileConfig.split('.');
+    let outputFileTailName = '';
+    let unHashedFileName = assetName;
+    if ((null == splitFilesList ? void 0 : splitFilesList.length) && splitFilesList.length >= 3 && (null == (_splitFilesList_ = splitFilesList[splitFilesList.length - 2]) ? void 0 : _splitFilesList_.indexOf('[')) < 0 && EXT.indexOf(splitFilesList[splitFilesList.length - 1]) > -1) {
+        outputFileTailName = splitFilesList[splitFilesList.length - 2];
+        const _regPattern = /(.*)(\.[a-f0-9]{4,32})([^.]*.[^.]+){2,}/g;
+        unHashedFileName = assetName.replace(_regPattern, '$1');
+        return `${unHashedFileName}.${outputFileTailName}.${assetName.substring(assetName.lastIndexOf('.') + 1)}`;
+    }
+    return assetName.replace(filenamePattern, '$1$2');
 }
 function isAssetMatchExtension(asset, ext) {
-  return asset.path.slice(-ext.length) === ext || extname(asset.path) === ext;
+    return asset.path.slice(-ext.length) === ext || extname(asset.path) === ext;
 }
 function isAssetMatchExtensions(asset, exts) {
-  if (!exts.length)
-    return false;
-  return exts.some((ext) => isAssetMatchExtension(asset, ext));
+    if (!exts.length) return false;
+    return exts.some((ext)=>isAssetMatchExtension(asset, ext));
 }
 function filterAssetsByExtensions(assets, exts) {
-  if (typeof exts === "string")
-    return assets.filter((e) => isAssetMatchExtension(e, exts));
-  if (Array.isArray(exts)) {
-    return assets.filter((e) => isAssetMatchExtensions(e, exts));
-  }
-  return [];
+    if ('string' == typeof exts) return assets.filter((e)=>isAssetMatchExtension(e, exts));
+    if (Array.isArray(exts)) return assets.filter((e)=>isAssetMatchExtensions(e, exts));
+    return [];
 }
 function filterAssets(assets, filterOrExtensions) {
-  if (filterOrExtensions) {
-    if (typeof filterOrExtensions === "function") {
-      assets = assets.filter(filterOrExtensions);
-    } else {
-      assets = filterAssetsByExtensions(assets, filterOrExtensions);
-    }
-  }
-  return assets;
+    if (filterOrExtensions) assets = 'function' == typeof filterOrExtensions ? assets.filter(filterOrExtensions) : filterAssetsByExtensions(assets, filterOrExtensions);
+    return assets;
 }
 function getAssetsSizeInfo(assets, chunks, options = {}) {
-  const { withFileContent = true, filterOrExtensions } = options;
-  assets = assets.filter(
-    (e) => !isAssetMatchExtensions(e, import_types.Constants.MapExtensions)
-  );
-  if (filterOrExtensions) {
-    assets = filterAssets(assets, filterOrExtensions);
-  }
-  if (assets.length) {
+    const { withFileContent = true, filterOrExtensions } = options;
+    assets = assets.filter((e)=>!isAssetMatchExtensions(e, types_namespaceObject.Constants.MapExtensions));
+    if (filterOrExtensions) assets = filterAssets(assets, filterOrExtensions);
+    if (assets.length) return {
+        count: assets.length,
+        size: assets.reduce((t, c)=>t + c.size, 0),
+        files: assets.map((e)=>({
+                path: e.path,
+                size: e.size,
+                gzipSize: e.gzipSize,
+                initial: isInitialAsset(e, chunks),
+                content: withFileContent ? e.content : void 0
+            }))
+    };
     return {
-      count: assets.length,
-      size: assets.reduce((t, c) => t + c.size, 0),
-      files: assets.map((e) => ({
-        path: e.path,
-        size: e.size,
-        gzipSize: e.gzipSize,
-        initial: isInitialAsset(e, chunks),
-        content: withFileContent ? e.content : void 0
-      }))
+        count: 0,
+        size: 0,
+        files: []
     };
-  }
-  return {
-    count: 0,
-    size: 0,
-    files: []
-  };
 }
 function isInitialAsset(asset, chunks) {
-  const cks = (0, import_chunk.getChunksByAsset)(asset, chunks);
-  return cks.some((e) => Boolean(e.initial));
+    const cks = (0, external_chunk_js_namespaceObject.getChunksByAsset)(asset, chunks);
+    return cks.some((e)=>Boolean(e.initial));
 }
 function getInitialAssetsSizeInfo(assets, chunks, options = {}) {
-  if (options.filterOrExtensions) {
-    assets = filterAssets(assets, options.filterOrExtensions);
-  }
-  return getAssetsSizeInfo(assets, chunks, {
-    ...options,
-    filterOrExtensions: (asset) => isInitialAsset(asset, chunks)
-  });
+    if (options.filterOrExtensions) assets = filterAssets(assets, options.filterOrExtensions);
+    return getAssetsSizeInfo(assets, chunks, {
+        ...options,
+        filterOrExtensions: (asset)=>isInitialAsset(asset, chunks)
+    });
 }
 function getAssetsDiffResult(baseline, current) {
-  return {
-    all: {
-      total: diffAssetsByExtensions(baseline, current)
-    },
-    js: {
-      total: diffAssetsByExtensions(baseline, current, import_types.Constants.JSExtension),
-      initial: diffAssetsByExtensions(
-        baseline,
-        current,
-        import_types.Constants.JSExtension,
-        true
-      )
-    },
-    css: {
-      total: diffAssetsByExtensions(baseline, current, import_types.Constants.CSSExtension),
-      initial: diffAssetsByExtensions(
-        baseline,
-        current,
-        import_types.Constants.CSSExtension,
-        true
-      )
-    },
-    imgs: {
-      total: diffAssetsByExtensions(baseline, current, import_types.Constants.ImgExtensions)
-    },
-    html: {
-      total: diffAssetsByExtensions(baseline, current, import_types.Constants.HtmlExtension)
-    },
-    media: {
-      total: diffAssetsByExtensions(
-        baseline,
-        current,
-        import_types.Constants.MediaExtensions
-      )
-    },
-    fonts: {
-      total: diffAssetsByExtensions(
-        baseline,
-        current,
-        import_types.Constants.FontExtensions
-      )
-    },
-    others: {
-      total: diffAssetsByExtensions(
-        baseline,
-        current,
-        (asset) => !isAssetMatchExtensions(
-          asset,
-          [
-            import_types.Constants.JSExtension,
-            import_types.Constants.CSSExtension,
-            import_types.Constants.HtmlExtension
-          ].concat(
-            import_types.Constants.ImgExtensions,
-            import_types.Constants.MediaExtensions,
-            import_types.Constants.FontExtensions,
-            import_types.Constants.MapExtensions
-          )
-        )
-      )
-    }
-  };
+    return {
+        all: {
+            total: diffAssetsByExtensions(baseline, current)
+        },
+        js: {
+            total: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.JSExtension),
+            initial: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.JSExtension, true)
+        },
+        css: {
+            total: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.CSSExtension),
+            initial: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.CSSExtension, true)
+        },
+        imgs: {
+            total: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.ImgExtensions)
+        },
+        html: {
+            total: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.HtmlExtension)
+        },
+        media: {
+            total: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.MediaExtensions)
+        },
+        fonts: {
+            total: diffAssetsByExtensions(baseline, current, types_namespaceObject.Constants.FontExtensions)
+        },
+        others: {
+            total: diffAssetsByExtensions(baseline, current, (asset)=>!isAssetMatchExtensions(asset, [
+                    types_namespaceObject.Constants.JSExtension,
+                    types_namespaceObject.Constants.CSSExtension,
+                    types_namespaceObject.Constants.HtmlExtension
+                ].concat(types_namespaceObject.Constants.ImgExtensions, types_namespaceObject.Constants.MediaExtensions, types_namespaceObject.Constants.FontExtensions, types_namespaceObject.Constants.MapExtensions)))
+        }
+    };
 }
 function diffSize(bSize, cSize) {
-  const isEqual = bSize === cSize;
-  const percent = isEqual ? 0 : bSize === 0 ? 100 : Math.abs(cSize - bSize) / bSize * 100;
-  const state = isEqual ? import_types.Client.RsdoctorClientDiffState.Equal : bSize > cSize ? import_types.Client.RsdoctorClientDiffState.Down : import_types.Client.RsdoctorClientDiffState.Up;
-  return { percent, state };
+    const isEqual = bSize === cSize;
+    const percent = isEqual ? 0 : 0 === bSize ? 100 : Math.abs(cSize - bSize) / bSize * 100;
+    const state = isEqual ? types_namespaceObject.Client.RsdoctorClientDiffState.Equal : bSize > cSize ? types_namespaceObject.Client.RsdoctorClientDiffState.Down : types_namespaceObject.Client.RsdoctorClientDiffState.Up;
+    return {
+        percent,
+        state
+    };
 }
 function diffAssetsByExtensions(baseline, current, filterOrExtensions, isInitial = false) {
-  const { size: bSize, count: bCount } = isInitial ? getInitialAssetsSizeInfo(baseline.assets, baseline.chunks, {
-    filterOrExtensions
-  }) : getAssetsSizeInfo(baseline.assets, baseline.chunks, {
-    filterOrExtensions
-  });
-  let cSize;
-  let cCount;
-  if (baseline === current) {
-    cSize = bSize;
-    cCount = bCount;
-  } else {
-    const { size, count } = isInitial ? getInitialAssetsSizeInfo(current.assets, current.chunks, {
-      filterOrExtensions
-    }) : getAssetsSizeInfo(current.assets, current.chunks, {
-      filterOrExtensions
+    const { size: bSize, count: bCount } = isInitial ? getInitialAssetsSizeInfo(baseline.assets, baseline.chunks, {
+        filterOrExtensions
+    }) : getAssetsSizeInfo(baseline.assets, baseline.chunks, {
+        filterOrExtensions
     });
-    cSize = size;
-    cCount = count;
-  }
-  const { percent, state } = diffSize(bSize, cSize);
-  return {
-    size: {
-      baseline: bSize,
-      current: cSize
-    },
-    count: {
-      baseline: bCount,
-      current: cCount
-    },
-    percent,
-    state
-  };
+    let cSize;
+    let cCount;
+    if (baseline === current) {
+        cSize = bSize;
+        cCount = bCount;
+    } else {
+        const { size, count } = isInitial ? getInitialAssetsSizeInfo(current.assets, current.chunks, {
+            filterOrExtensions
+        }) : getAssetsSizeInfo(current.assets, current.chunks, {
+            filterOrExtensions
+        });
+        cSize = size;
+        cCount = count;
+    }
+    const { percent, state } = diffSize(bSize, cSize);
+    return {
+        size: {
+            baseline: bSize,
+            current: cSize
+        },
+        count: {
+            baseline: bCount,
+            current: cCount
+        },
+        percent,
+        state
+    };
 }
 function getAssetsSummary(assets, chunks, options = {}) {
-  const jsOpt = {
-    ...options,
-    filterOrExtensions: import_types.Constants.JSExtension
-  };
-  const cssOpt = {
-    ...options,
-    filterOrExtensions: import_types.Constants.CSSExtension
-  };
-  const imgOpt = {
-    ...options,
-    filterOrExtensions: import_types.Constants.ImgExtensions
-  };
-  const htmlOpt = {
-    ...options,
-    filterOrExtensions: import_types.Constants.HtmlExtension
-  };
-  const mediaOpt = {
-    ...options,
-    filterOrExtensions: import_types.Constants.MediaExtensions
-  };
-  const fontOpt = {
-    ...options,
-    filterOrExtensions: import_types.Constants.FontExtensions
-  };
-  const otherOpt = {
-    ...options,
-    filterOrExtensions: (asset) => !isAssetMatchExtensions(
-      asset,
-      [
-        import_types.Constants.JSExtension,
-        import_types.Constants.CSSExtension,
-        import_types.Constants.HtmlExtension
-      ].concat(
-        import_types.Constants.ImgExtensions,
-        import_types.Constants.MediaExtensions,
-        import_types.Constants.FontExtensions,
-        import_types.Constants.MapExtensions
-      )
-    )
-  };
-  return {
-    all: {
-      total: getAssetsSizeInfo(assets, chunks, options)
-    },
-    js: {
-      total: getAssetsSizeInfo(assets, chunks, jsOpt),
-      initial: getInitialAssetsSizeInfo(assets, chunks, jsOpt)
-    },
-    css: {
-      total: getAssetsSizeInfo(assets, chunks, cssOpt),
-      initial: getInitialAssetsSizeInfo(assets, chunks, cssOpt)
-    },
-    imgs: {
-      total: getAssetsSizeInfo(assets, chunks, imgOpt)
-    },
-    html: {
-      total: getAssetsSizeInfo(assets, chunks, htmlOpt)
-    },
-    media: {
-      total: getAssetsSizeInfo(assets, chunks, mediaOpt)
-    },
-    fonts: {
-      total: getAssetsSizeInfo(assets, chunks, fontOpt)
-    },
-    others: {
-      total: getAssetsSizeInfo(assets, chunks, otherOpt)
-    }
-  };
+    const jsOpt = {
+        ...options,
+        filterOrExtensions: types_namespaceObject.Constants.JSExtension
+    };
+    const cssOpt = {
+        ...options,
+        filterOrExtensions: types_namespaceObject.Constants.CSSExtension
+    };
+    const imgOpt = {
+        ...options,
+        filterOrExtensions: types_namespaceObject.Constants.ImgExtensions
+    };
+    const htmlOpt = {
+        ...options,
+        filterOrExtensions: types_namespaceObject.Constants.HtmlExtension
+    };
+    const mediaOpt = {
+        ...options,
+        filterOrExtensions: types_namespaceObject.Constants.MediaExtensions
+    };
+    const fontOpt = {
+        ...options,
+        filterOrExtensions: types_namespaceObject.Constants.FontExtensions
+    };
+    const otherOpt = {
+        ...options,
+        filterOrExtensions: (asset)=>!isAssetMatchExtensions(asset, [
+                types_namespaceObject.Constants.JSExtension,
+                types_namespaceObject.Constants.CSSExtension,
+                types_namespaceObject.Constants.HtmlExtension
+            ].concat(types_namespaceObject.Constants.ImgExtensions, types_namespaceObject.Constants.MediaExtensions, types_namespaceObject.Constants.FontExtensions, types_namespaceObject.Constants.MapExtensions))
+    };
+    return {
+        all: {
+            total: getAssetsSizeInfo(assets, chunks, options)
+        },
+        js: {
+            total: getAssetsSizeInfo(assets, chunks, jsOpt),
+            initial: getInitialAssetsSizeInfo(assets, chunks, jsOpt)
+        },
+        css: {
+            total: getAssetsSizeInfo(assets, chunks, cssOpt),
+            initial: getInitialAssetsSizeInfo(assets, chunks, cssOpt)
+        },
+        imgs: {
+            total: getAssetsSizeInfo(assets, chunks, imgOpt)
+        },
+        html: {
+            total: getAssetsSizeInfo(assets, chunks, htmlOpt)
+        },
+        media: {
+            total: getAssetsSizeInfo(assets, chunks, mediaOpt)
+        },
+        fonts: {
+            total: getAssetsSizeInfo(assets, chunks, fontOpt)
+        },
+        others: {
+            total: getAssetsSizeInfo(assets, chunks, otherOpt)
+        }
+    };
 }
 function getAssetDetails(assetPath, assets, chunks, modules) {
-  const asset = assets.find((e) => e.path === assetPath);
-  return {
-    asset,
-    chunks: (0, import_chunk.getChunksByAsset)(asset, chunks),
-    modules: (0, import_modules.getModulesByAsset)(asset, chunks, modules)
-  };
+    const asset = assets.find((e)=>e.path === assetPath);
+    return {
+        asset,
+        chunks: (0, external_chunk_js_namespaceObject.getChunksByAsset)(asset, chunks),
+        modules: (0, external_modules_js_namespaceObject.getModulesByAsset)(asset, chunks, modules)
+    };
 }
 function getAllBundleData(assets, chunks, modules, filtersModules) {
-  const result = [];
-  try {
-    for (let i = 0; i < assets.length; i++) {
-      const asset = assets[i];
-      result.push({
-        asset,
-        modules: (0, import_modules.getModulesByAsset)(asset, chunks, modules, filtersModules)
-      });
+    const result = [];
+    try {
+        for(let i = 0; i < assets.length; i++){
+            const asset = assets[i];
+            result.push({
+                asset,
+                modules: (0, external_modules_js_namespaceObject.getModulesByAsset)(asset, chunks, modules, filtersModules)
+            });
+        }
+        return result;
+    } catch (error) {
+        console.error(error);
+        return [];
     }
-    return result;
-  } catch (error) {
-    console.error(error);
-    return [];
-  }
 }
 function extname(filename) {
-  const baseName = filename.split("?")[0];
-  const matches = baseName.match(/\.([0-9a-z]+)(?:[\?#]|$)/i);
-  return matches ? `.${matches[1]}` : "";
+    const baseName = filename.split('?')[0];
+    const matches = baseName.match(/\.([0-9a-z]+)(?:[\?#]|$)/i);
+    return matches ? `.${matches[1]}` : '';
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  diffAssetsByExtensions,
-  diffSize,
-  extname,
-  filterAssets,
-  filterAssetsByExtensions,
-  formatAssetName,
-  getAllBundleData,
-  getAssetDetails,
-  getAssetsDiffResult,
-  getAssetsSizeInfo,
-  getAssetsSummary,
-  getInitialAssetsSizeInfo,
-  isAssetMatchExtension,
-  isAssetMatchExtensions,
-  isInitialAsset
+exports.diffAssetsByExtensions = __webpack_exports__.diffAssetsByExtensions;
+exports.diffSize = __webpack_exports__.diffSize;
+exports.extname = __webpack_exports__.extname;
+exports.filterAssets = __webpack_exports__.filterAssets;
+exports.filterAssetsByExtensions = __webpack_exports__.filterAssetsByExtensions;
+exports.formatAssetName = __webpack_exports__.formatAssetName;
+exports.getAllBundleData = __webpack_exports__.getAllBundleData;
+exports.getAssetDetails = __webpack_exports__.getAssetDetails;
+exports.getAssetsDiffResult = __webpack_exports__.getAssetsDiffResult;
+exports.getAssetsSizeInfo = __webpack_exports__.getAssetsSizeInfo;
+exports.getAssetsSummary = __webpack_exports__.getAssetsSummary;
+exports.getInitialAssetsSizeInfo = __webpack_exports__.getInitialAssetsSizeInfo;
+exports.isAssetMatchExtension = __webpack_exports__.isAssetMatchExtension;
+exports.isAssetMatchExtensions = __webpack_exports__.isAssetMatchExtensions;
+exports.isInitialAsset = __webpack_exports__.isInitialAsset;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "diffAssetsByExtensions",
+    "diffSize",
+    "extname",
+    "filterAssets",
+    "filterAssetsByExtensions",
+    "formatAssetName",
+    "getAllBundleData",
+    "getAssetDetails",
+    "getAssetsDiffResult",
+    "getAssetsSizeInfo",
+    "getAssetsSummary",
+    "getInitialAssetsSizeInfo",
+    "isAssetMatchExtension",
+    "isAssetMatchExtensions",
+    "isInitialAsset"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });