balm-core 5.0.1 → 5.1.0

package/tslib/plugins/sass.js

@@ -1,86 +1,61 @@
-import fs from 'node:fs';
-import { pathToFileURL } from 'node:url';
 import { Transform } from 'node:stream';
-import semver from 'semver';
 import * as sass from 'sass';
 import replaceExtension from 'replace-ext';
 import stripAnsi from 'strip-ansi';
 import applySourceMap from 'vinyl-sourcemaps-apply';
 import ansiColors from 'ansi-colors';
-process.env.BALM_CWD = process.env.INIT_CWD || process.cwd();
-const localSassModule = node.path.join(process.env.BALM_CWD, 'node_modules', 'sass');
-let isLegacy = false;
-try {
-    const sassPkg = requireModule(node.path.join(localSassModule, 'package.json'));
-    isLegacy = semver.lt(sassPkg.version, '1.40.0');
-}
-catch (_) { }
-const nodeLocalSassModule = node.path.join(localSassModule, 'sass.node.js');
-const defaultLocalSassModule = node.path.join(localSassModule, 'sass.default.js');
-const dartLocalSassModule = node.path.join(localSassModule, 'sass.dart.js');
-const sassModule = fs.existsSync(nodeLocalSassModule)
-    ? requireModule(nodeLocalSassModule)
-    : fs.existsSync(defaultLocalSassModule)
-        ? requireModule(defaultLocalSassModule)
-        : fs.existsSync(dartLocalSassModule)
-            ? requireModule(dartLocalSassModule)
-            : sass;
+const sassModule = node.getSassModule(sass);
 const PLUGIN_NAME = 'sass';
 const transformObj = (transform) => new Transform({ transform, objectMode: true });
 function filePush(file, result, callback) {
-    if (result.sourceMap) {
-        const sassMap = result.sourceMap;
-        sassMap.file = replaceExtension(file.relative, '.css');
-        applySourceMap(file, sassMap);
-    }
     file.contents = Buffer.from(result.css);
     file.path = replaceExtension(file.path, '.css');
-    if (file.stat) {
-        file.stat.atime = file.stat.mtime = file.stat.ctime = new Date();
-    }
-    callback(null, file);
-}
-function legacyFilePush(file, sassObject, callback) {
-    if (sassObject.map) {
-        const sassMap = JSON.parse(sassObject.map.toString());
-        const sassMapFile = sassMap.file.replace(/^stdout$/, 'stdin');
-        const sassFileSrc = file.relative;
-        const sassFileSrcPath = node.path.dirname(sassFileSrc);
-        if (sassFileSrcPath) {
-            const sourceFileIndex = sassMap.sources.indexOf(sassMapFile);
-            sassMap.sources = sassMap.sources.map((source, index) => index === sourceFileIndex
-                ? source
-                : node.path.join(sassFileSrcPath, source));
+    if (result.sourceMap) {
+        const proto = /^file:\/\/?/;
+        const leadingSlash = /^\//;
+        const sassMap = result.sourceMap;
+        const base = node.path.resolve(file.cwd, file.base);
+        if (!sassMap.file) {
+            sassMap.file = file.history[0]
+                .replace(base + node.path.sep, '')
+                .replace(proto, '');
         }
-        sassMap.sources = sassMap.sources.filter((src) => src !== 'stdin' && src);
+        sassMap.sources = sassMap.sources.map((src) => {
+            const baseUri = base.replace(/\\/g, '/');
+            if (src.startsWith('data:')) {
+                return file.history[0]
+                    .replace(/\\/g, '/')
+                    .replace(`${baseUri}/`, '')
+                    .replace(proto, '')
+                    .replace(leadingSlash, '');
+            }
+            return src
+                .replace(proto, '')
+                .replace(`${baseUri}/`, '')
+                .replace(leadingSlash, '');
+        });
+        const sassFileSrc = file.relative;
         sassMap.file = replaceExtension(sassFileSrc, '.css');
+        if (file.sourceMap &&
+            file.sourceMap.sourcesContent &&
+            !sassMap.sourcesContent) {
+            sassMap.sourcesContent = file.sourceMap.sourcesContent;
+        }
         applySourceMap(file, sassMap);
     }
-    file.contents = sassObject.css;
-    file.path = replaceExtension(file.path, '.css');
     if (file.stat) {
         file.stat.atime = file.stat.mtime = file.stat.ctime = new Date();
     }
     callback(null, file);
 }
 function handleError(error, file, callback) {
-    const relativePath = node.path.relative(process.cwd(), file.path);
-    const message = `${ansiColors.underline(relativePath)}\n${error.message}`;
-    error.message = stripAnsi(message);
-    return callback(new PluginError(PLUGIN_NAME, error));
-}
-function legacyHandleError(error, file, callback) {
-    const filePath = ((error.file === 'stdin' ? file.path : error.file) ||
-        file.path);
+    const filePath = (error.file === 'stdin' ? file.path : error.file) || file.path;
     const relativePath = node.path.relative(process.cwd(), filePath);
-    const message = `${ansiColors.underline(relativePath)}\n${error.formatted}`;
-    error.messageFormatted = message;
-    error.messageOriginal = error.message;
+    const message = `${ansiColors.underline(relativePath)}\n${error.message}`;
     error.message = stripAnsi(message);
-    error.relativePath = relativePath;
     return callback(new PluginError(PLUGIN_NAME, error));
 }
-const gulpSass = (options) => transformObj((file, encoding, callback) => {
+const gulpSass = (options, sync = false) => transformObj((file, encoding, callback) => {
     if (file.isNull()) {
         return callback(null, file);
     }
@@ -95,77 +70,40 @@ const gulpSass = (options) => transformObj((file, encoding, callback) => {
         return callback(null, file);
     }
     const opts = (options || {});
-    if (isLegacy) {
-        opts.data = file.contents.toString();
-        opts.file = file.path;
-        if (node.path.extname(file.path) === '.sass') {
-            opts.indentedSyntax = true;
-        }
-        if (opts.includePaths) {
-            if (typeof opts.includePaths === 'string') {
-                opts.includePaths = [opts.includePaths];
-            }
-        }
-        else {
-            opts.includePaths = [];
-        }
-        opts.includePaths.unshift(node.path.dirname(file.path));
-        if (file.sourceMap) {
-            opts.sourceMap = file.path;
-            opts.omitSourceMapUrl = true;
-            opts.sourceMapContents = true;
-        }
-        if (!opts.importer) {
-            const aliasKeys = Object.keys(BalmJS.config.scripts.alias).filter((key) => /^@[a-z0-9-]{1,213}/.test(key));
-            if (aliasKeys.length) {
-                const aliasKeyRegex = new RegExp(`^(${aliasKeys.join('|')})/`);
-                opts.importer = [
-                    function (url) {
-                        let file = url;
-                        const result = url.match(aliasKeyRegex);
-                        const key = result ? result[1] : null;
-                        if (key) {
-                            file = url.replace(key, BalmJS.config.scripts.alias[key]);
-                            BalmJS.logger.debug(`${PLUGIN_NAME} alias`, `${key} -> ${url} => ${file}`);
-                        }
-                        return { file };
-                    }
-                ];
-            }
+    if (node.path.extname(file.path) === '.sass') {
+        opts.syntax = 'indented';
+    }
+    if (opts.loadPaths) {
+        if (typeof opts.loadPaths === 'string') {
+            opts.loadPaths = [opts.loadPaths];
         }
     }
     else {
-        if (!options.importers) {
-            const aliasKeys = Object.keys(BalmJS.config.scripts.alias).filter((key) => /^@[a-z0-9-]{1,213}/.test(key));
-            if (aliasKeys.length) {
-                const aliasKeyRegex = new RegExp(`^(${aliasKeys.join('|')})/`);
-                options.importers = [
-                    {
-                        findFileUrl(url) {
-                            let file = url;
-                            const result = url.match(aliasKeyRegex);
-                            const key = result ? result[1] : null;
-                            if (key) {
-                                file = url.replace(key, BalmJS.config.scripts.alias[key]);
-                                BalmJS.logger.debug(`${PLUGIN_NAME} alias`, `${key} -> ${url} => ${file}`);
-                            }
-                            return pathToFileURL(file);
-                        }
-                    }
-                ];
-            }
-        }
+        opts.loadPaths = [];
     }
-    try {
-        isLegacy
-            ? legacyFilePush(file, sassModule.renderSync(opts), callback)
-            : filePush(file, sassModule.compile(file.path, options), callback);
+    opts.loadPaths.unshift(node.path.dirname(file.path));
+    if (file.sourceMap) {
+        opts.sourceMap = true;
+        opts.sourceMapIncludeSources = true;
     }
-    catch (error) {
-        isLegacy
-            ? legacyHandleError(error, file, callback)
-            : handleError(error, file, callback);
+    const fileContents = file.contents.toString();
+    if (sync !== true) {
+        sassModule
+            .compileStringAsync(fileContents, opts)
+            .then((compileResult) => {
+            filePush(file, compileResult, callback);
+        })
+            .catch((error) => {
+            handleError(error, file, callback);
+        });
+    }
+    else {
+        try {
+            filePush(file, sassModule.compileString(fileContents, opts), callback);
+        }
+        catch (error) {
+            handleError(error, file, callback);
+        }
     }
 });
 export default gulpSass;
-export { isLegacy };

package/tslib/tasks/foundation/balm.js

@@ -1,11 +1,13 @@
 class BalmTask {
+    name;
+    taskName;
+    defaultInput = '';
+    defaultOutput = '';
+    input = '';
+    output = '';
+    customOptions = {};
+    gulpSrcOptions = {};
     constructor(name) {
-        this.defaultInput = '';
-        this.defaultOutput = '';
-        this.input = '';
-        this.output = '';
-        this.customOptions = {};
-        this.gulpSrcOptions = {};
         this.name = name;
         this.taskName = BalmJS.toNamespace(name);
     }
@@ -27,7 +29,8 @@ class BalmTask {
     get src() {
         return gulp
             .src(this.input, Object.assign({
-            allowEmpty: true
+            allowEmpty: true,
+            encoding: false
         }, this.gulpSrcOptions))
             .pipe(BalmJS.plugins.plumber((error) => {
             BalmJS.logger.error(`${this.name} task`, error.message);

package/tslib/tasks/foundation/balm_style.js

@@ -47,7 +47,9 @@ class BalmStyleTask extends BalmTask {
         }));
         switch (style) {
             case 'sass':
-                stream = stream.pipe(BalmJS.plugins.sass(options));
+                stream = stream.pipe(node.isLegacySass
+                    ? BalmJS.plugins.legacySass(options)
+                    : BalmJS.plugins.sass(options));
                 break;
             case 'less':
                 stream = stream.pipe(BalmJS.plugins.less(options));

package/tslib/tasks/private/build.js

@@ -2,14 +2,14 @@ import gulpSize from 'gulp-size';
 class BuildTask extends BalmJS.BalmTask {
     constructor() {
         super('build');
-        this.fn = () => {
-            this.init();
-            return this.src.pipe(gulpSize({
-                title: this.name,
-                gzip: true
-            }));
-        };
         this.defaultInput = BalmJS.file.matchAllFiles(BalmJS.config.dest.base);
     }
+    fn = () => {
+        this.init();
+        return this.src.pipe(gulpSize({
+            title: this.name,
+            gzip: true
+        }));
+    };
 }
 export default BuildTask;

package/tslib/tasks/private/cache.js

@@ -3,16 +3,6 @@ import { ASSETS_TYPES, CHUNK, ASSET } from '../../config/constants.js';
 class CacheTask extends BalmJS.BalmTask {
     constructor() {
         super('cache');
-        this.fn = () => {
-            this.init();
-            return this.src
-                .pipe(revAll.revision(BalmJS.config.assets.options))
-                .pipe($.if(/\.html$/, BalmJS.file.setPublicPath()))
-                .pipe(gulp.dest(this.output))
-                .pipe($.revDeleteOriginal())
-                .pipe(revAll.manifestFile())
-                .pipe(gulp.dest(this.output));
-        };
         const defaultIncludes = BalmJS.config.scripts.useCache
             ? ASSETS_TYPES.filter((assetType) => assetType !== 'js').map((assetType) => BalmJS.file.matchAllFiles(BalmJS.config.dest[assetType]))
             : ASSETS_TYPES.map((assetType) => BalmJS.file.matchAllFiles(BalmJS.config.dest[assetType]));
@@ -38,5 +28,15 @@ class CacheTask extends BalmJS.BalmTask {
             ? BalmJS.config.dest.base
             : BalmJS.config.dest.static;
     }
+    fn = () => {
+        this.init();
+        return this.src
+            .pipe(revAll.revision(BalmJS.config.assets.options))
+            .pipe($.if(/\.html$/, BalmJS.file.setPublicPath()))
+            .pipe(gulp.dest(this.output))
+            .pipe($.revDeleteOriginal())
+            .pipe(revAll.manifestFile())
+            .pipe(gulp.dest(this.output));
+    };
 }
 export default CacheTask;

package/tslib/tasks/private/clean.js

@@ -1,5 +1,3 @@
-var _CleanTask_getAssetsDir;
-import { __classPrivateFieldGet } from "tslib";
 import { deleteAsync } from 'del';
 import { ASSETS_TYPES } from '../../config/constants.js';
 function unique(arr) {
@@ -16,33 +14,10 @@ function unique(arr) {
 class CleanTask extends BalmJS.BalmTask {
     constructor() {
         super('clean');
-        _CleanTask_getAssetsDir.set(this, (rootKey = 'assets') => {
-            return unique(ASSETS_TYPES.map((assetType) => BalmJS.config[rootKey][assetType]));
-        });
-        this.fn = async (callback) => {
-            const taskName = `${this.name} task`;
-            const directories = BalmJS.config.inFrontend
-                ? this.dirInFrontend
-                : this.dirInBackend;
-            if (BalmJS.config.env.isProd && !BalmJS.config.assets.root) {
-                BalmJS.logger.warn(taskName, 'Remote root path is empty');
-            }
-            BalmJS.logger.debug(taskName, {
-                directories
-            }, {
-                pre: true
-            });
-            const deletedPaths = await deleteAsync(directories, {
-                force: true
-            });
-            BalmJS.logger.warn(taskName, {
-                deletedPaths
-            }, {
-                pre: true
-            });
-            callback();
-        };
     }
+    #getAssetsDir = (rootKey = 'assets') => {
+        return unique(ASSETS_TYPES.map((assetType) => BalmJS.config[rootKey][assetType]));
+    };
     get remoteRootDir() {
         return BalmJS.config.assets.root.trim().length
             ? [BalmJS.config.assets.root]
@@ -51,7 +26,7 @@ class CleanTask extends BalmJS.BalmTask {
     get remoteAppDir() {
         return BalmJS.config.assets.subDir
             ? [BalmJS.config.assets.static]
-            : __classPrivateFieldGet(this, _CleanTask_getAssetsDir, "f").call(this);
+            : this.#getAssetsDir();
     }
     get dirInFrontend() {
         const isLocal = !node.path.isAbsolute(BalmJS.config.assets.root);
@@ -77,9 +52,31 @@ class CleanTask extends BalmJS.BalmTask {
         return [
             ...(BalmJS.config.env.isProd && hasBuildDir
                 ? buildDirInProd
-                : [...buildDirInDev, ...__classPrivateFieldGet(this, _CleanTask_getAssetsDir, "f").call(this, 'dest')])
+                : [...buildDirInDev, ...this.#getAssetsDir('dest')])
         ];
     }
+    fn = async (callback) => {
+        const taskName = `${this.name} task`;
+        const directories = BalmJS.config.inFrontend
+            ? this.dirInFrontend
+            : this.dirInBackend;
+        if (BalmJS.config.env.isProd && !BalmJS.config.assets.root) {
+            BalmJS.logger.warn(taskName, 'Remote root path is empty');
+        }
+        BalmJS.logger.debug(taskName, {
+            directories
+        }, {
+            pre: true
+        });
+        const deletedPaths = await deleteAsync(directories, {
+            force: true
+        });
+        BalmJS.logger.warn(taskName, {
+            deletedPaths
+        }, {
+            pre: true
+        });
+        callback();
+    };
 }
-_CleanTask_getAssetsDir = new WeakMap();
 export default CleanTask;

package/tslib/tasks/private/end.js

@@ -1,14 +1,6 @@
 class EndTask extends BalmJS.BalmTask {
     constructor() {
         super('end');
-        this.fn = async (callback) => {
-            if (BalmJS.utils.isFunction(BalmJS.afterTask)) {
-                await BalmJS.afterTask();
-            }
-            this.time();
-            BalmJS.emitter.emit('exit');
-            callback();
-        };
     }
     time() {
         const end = process.hrtime(BalmJS.start);
@@ -17,5 +9,13 @@ class EndTask extends BalmJS.BalmTask {
             logLevel: BalmJS.LogLevel.Error
         });
     }
+    fn = async (callback) => {
+        if (BalmJS.utils.isFunction(BalmJS.afterTask)) {
+            await BalmJS.afterTask();
+        }
+        this.time();
+        BalmJS.emitter.emit('exit');
+        callback();
+    };
 }
 export default EndTask;

package/tslib/tasks/private/extra.js

@@ -1,13 +1,6 @@
 class ExtraTask extends BalmJS.BalmTask {
     constructor() {
         super('extra');
-        this.fn = () => {
-            this.init();
-            this.gulpSrcOptions = {
-                dot: true
-            };
-            return this.src.pipe(gulp.dest(this.output));
-        };
         const includeGlobs = [];
         if (BalmJS.config.extras.includes.length) {
             for (const filename of BalmJS.config.extras.includes) {
@@ -30,5 +23,12 @@ class ExtraTask extends BalmJS.BalmTask {
         this.defaultInput = defaultGlobs;
         this.defaultOutput = BalmJS.config.dest.base;
     }
+    fn = () => {
+        this.init();
+        this.gulpSrcOptions = {
+            dot: true
+        };
+        return this.src.pipe(gulp.dest(this.output));
+    };
 }
 export default ExtraTask;

package/tslib/tasks/private/font.js

@@ -1,12 +1,12 @@
 class FontTask extends BalmJS.BalmTask {
     constructor() {
         super('font');
-        this.fn = () => {
-            this.init();
-            return this.src.pipe(gulp.dest(this.output));
-        };
         this.defaultInput = BalmJS.file.matchAllFiles(BalmJS.config.src.font, '*.{eot,svg,ttf,woff,woff2}');
         this.defaultOutput = BalmJS.config.dest.font;
     }
+    fn = () => {
+        this.init();
+        return this.src.pipe(gulp.dest(this.output));
+    };
 }
 export default FontTask;

package/tslib/tasks/private/image.js

@@ -2,21 +2,6 @@ import { getDefaultImagePlugins } from '../../plugins/imagemin.js';
 class ImageTask extends BalmJS.BalmTask {
     constructor() {
         super('image');
-        this.fn = () => {
-            this.init();
-            const balmImage = () => {
-                return gulp
-                    .src(BalmJS.file.absPaths(this.input), {
-                    since: gulp.lastRun(balmImage)
-                })
-                    .pipe(BalmJS.plugins.plumber((error) => {
-                    BalmJS.logger.error(`${this.name} task`, error);
-                }))
-                    .pipe(BalmJS.plugins.imagemin(this.plugins))
-                    .pipe(gulp.dest(this.output));
-            };
-            return balmImage();
-        };
         const excludeGlobs = [];
         for (const imageFolder of BalmJS.config.styles.sprites) {
             excludeGlobs.push(node.path.join(`!${BalmJS.config.src.img}`, imageFolder));
@@ -37,5 +22,21 @@ class ImageTask extends BalmJS.BalmTask {
             BalmJS.logger.debug(`${this.name} task - plugins`, enablePlugins);
         }
     }
+    fn = () => {
+        this.init();
+        const balmImage = () => {
+            return gulp
+                .src(BalmJS.file.absPaths(this.input), {
+                since: gulp.lastRun(balmImage),
+                encoding: false
+            })
+                .pipe(BalmJS.plugins.plumber((error) => {
+                BalmJS.logger.error(`${this.name} task`, error);
+            }))
+                .pipe(BalmJS.plugins.imagemin(this.plugins))
+                .pipe(gulp.dest(this.output));
+        };
+        return balmImage();
+    };
 }
 export default ImageTask;

package/tslib/tasks/private/lint.js

@@ -1,17 +1,17 @@
 class LintTask extends BalmJS.BalmTask {
     constructor() {
         super('lint');
-        this.fn = () => {
-            this.init();
-            return this.src
-                .pipe($.eslint({ fix: true }))
-                .pipe(server.reload({ stream: true, once: true }))
-                .pipe($.eslint.format())
-                .pipe($.if(!server.active, $.eslint.failAfterError()))
-                .pipe(gulp.dest(this.output));
-        };
         this.defaultOutput = BalmJS.config.src.js;
         this.defaultInput = BalmJS.file.matchAllFiles(this.defaultOutput, '*.js');
     }
+    fn = () => {
+        this.init();
+        return this.src
+            .pipe($.eslint({ fix: true }))
+            .pipe(server.reload({ stream: true, once: true }))
+            .pipe($.eslint.format())
+            .pipe($.if(!server.active, $.eslint.failAfterError()))
+            .pipe(gulp.dest(this.output));
+    };
 }
 export default LintTask;

package/tslib/tasks/private/media.js

@@ -1,12 +1,12 @@
 class MediaTask extends BalmJS.BalmTask {
     constructor() {
         super('media');
-        this.fn = () => {
-            this.init();
-            return this.src.pipe(gulp.dest(this.output));
-        };
         this.defaultInput = BalmJS.file.matchAllFiles(BalmJS.config.src.media);
         this.defaultOutput = BalmJS.config.dest.media;
     }
+    fn = () => {
+        this.init();
+        return this.src.pipe(gulp.dest(this.output));
+    };
 }
 export default MediaTask;

package/tslib/tasks/private/modernizr.js

@@ -1,57 +1,54 @@
-var _ModernizrTask_readConfig, _ModernizrTask_createDir, _ModernizrTask_generateScript;
-import { __classPrivateFieldGet } from "tslib";
 import { build } from 'modernizr';
 class ModernizrTask extends BalmJS.BalmTask {
     constructor() {
         super('modernizr');
-        _ModernizrTask_readConfig.set(this, () => {
-            return new Promise((resolve, reject) => {
-                node.fs.readFile(this.input, 'utf8', (err, data) => {
-                    if (err)
-                        reject(err);
-                    resolve(JSON.parse(data));
-                });
+        this.defaultInput = `${this.name}.json`;
+        this.defaultOutput = node.path.join(BalmJS.config.dest.js, `${this.name}.js`);
+    }
+    #readConfig = () => {
+        return new Promise((resolve, reject) => {
+            node.fs.readFile(this.input, 'utf8', (err, data) => {
+                if (err)
+                    reject(err);
+                resolve(JSON.parse(data));
+            });
+        });
+    };
+    #createDir = () => {
+        return new Promise((resolve, reject) => {
+            node.fs.mkdir(BalmJS.file.absPath(BalmJS.config.dest.js), { recursive: true }, (err) => {
+                if (err)
+                    reject(err);
+                resolve();
             });
         });
-        _ModernizrTask_createDir.set(this, () => {
-            return new Promise((resolve, reject) => {
-                node.fs.mkdir(BalmJS.file.absPath(BalmJS.config.dest.js), { recursive: true }, (err) => {
+    };
+    #generateScript = (config) => {
+        return new Promise((resolve, reject) => {
+            build(config, (content) => {
+                node.fs.writeFile(this.output, content, (err) => {
                     if (err)
                         reject(err);
-                    resolve();
+                    resolve(content);
                 });
             });
         });
-        _ModernizrTask_generateScript.set(this, (config) => {
-            return new Promise((resolve, reject) => {
-                build(config, (content) => {
-                    node.fs.writeFile(this.output, content, (err) => {
-                        if (err)
-                            reject(err);
-                        resolve(content);
-                    });
-                });
+    };
+    fn = async (callback) => {
+        this.init();
+        if (node.fs.existsSync(this.input)) {
+            const [config] = await Promise.all([
+                this.#readConfig(),
+                this.#createDir()
+            ]);
+            await this.#generateScript(config);
+        }
+        else {
+            BalmJS.logger.warn(`${this.name} task`, `The '${this.input}' does not exist`, {
+                logLevel: BalmJS.LogLevel.Info
             });
-        });
-        this.fn = async (callback) => {
-            this.init();
-            if (node.fs.existsSync(this.input)) {
-                const [config] = await Promise.all([
-                    __classPrivateFieldGet(this, _ModernizrTask_readConfig, "f").call(this),
-                    __classPrivateFieldGet(this, _ModernizrTask_createDir, "f").call(this)
-                ]);
-                await __classPrivateFieldGet(this, _ModernizrTask_generateScript, "f").call(this, config);
-            }
-            else {
-                BalmJS.logger.warn(`${this.name} task`, `The '${this.input}' does not exist`, {
-                    logLevel: BalmJS.LogLevel.Info
-                });
-            }
-            callback();
-        };
-        this.defaultInput = `${this.name}.json`;
-        this.defaultOutput = node.path.join(BalmJS.config.dest.js, `${this.name}.js`);
-    }
+        }
+        callback();
+    };
 }
-_ModernizrTask_readConfig = new WeakMap(), _ModernizrTask_createDir = new WeakMap(), _ModernizrTask_generateScript = new WeakMap();
 export default ModernizrTask;