@shuvi/toolpack 0.0.1-rc.9 → 1.0.0-rc.10

package/lib/webpack/loaders/parcel-css-loader/CssSyntaxError.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function showSourceCode(source, lineNo, columnNo) {
+    if (!source)
+        return '';
+    let lines = source.split(/\r?\n/);
+    let start = Math.max(lineNo - 3, 0);
+    let end = Math.min(lineNo + 2, lines.length);
+    let maxWidth = String(end).length;
+    return lines
+        .slice(start, end)
+        .map((line, index) => {
+        let number = start + 1 + index;
+        let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
+        if (number === lineNo) {
+            let spacing = gutter.replace(/\d/g, ' ') +
+                line.slice(0, columnNo - 1).replace(/[^\t]/g, ' ');
+            return '>' + gutter + line + '\n ' + spacing + '^';
+        }
+        return ' ' + gutter + line;
+    })
+        .join('\n');
+}
+class CssSyntaxError extends Error {
+    constructor(error) {
+        super();
+        const { source, fileName, loc } = error;
+        const { line, column } = loc;
+        this.message = `\n\n${this.message}\n\n`;
+        this.message += `${fileName || `<css input>`}`;
+        if (typeof line !== 'undefined') {
+            this.message += `(${line}:${column}) \n`;
+        }
+        this.message += `\n${showSourceCode(source, line, column)}\n`;
+        // We don't need stack https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror
+        // @ts-ignore
+        this.stack = false;
+    }
+}
+exports.default = CssSyntaxError;

package/lib/webpack/loaders/parcel-css-loader/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { loader } from 'webpack';
+export default function loader(this: loader.LoaderContext, content: string | Buffer, map?: string): Promise<void>;
+export declare const raw = true;

package/lib/webpack/loaders/parcel-css-loader/index.js

@@ -0,0 +1,369 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raw = void 0;
+const path = __importStar(require("path"));
+const browserslist_1 = __importDefault(require("browserslist"));
+const css_1 = require("@parcel/css");
+const CssSyntaxError_1 = __importDefault(require("./CssSyntaxError"));
+const utils_1 = require("./utils");
+const browsersTargets = (0, css_1.browserslistToTargets)((0, browserslist_1.default)('last 1 major versions'));
+function loader(content, map) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rawOptions = this.getOptions();
+        const callback = this.async();
+        let options;
+        try {
+            options = (0, utils_1.normalizeOptions)(rawOptions, this);
+        }
+        catch (error) {
+            if (callback) {
+                callback(error);
+            }
+            return;
+        }
+        let isSupportAbsoluteURL = false;
+        // TODO enable by default in the next major release
+        if (this._compilation &&
+            this._compilation.options &&
+            this._compilation.options.experiments &&
+            this._compilation.options.experiments.buildHttp) {
+            isSupportAbsoluteURL = true;
+        }
+        const isSupportDataURL = options.esModule && Boolean('fsStartTime' in this._compiler);
+        const needToUseIcssPlugin = (0, utils_1.shouldUseIcssPlugin)(options);
+        let ParcelCssRes;
+        try {
+            ParcelCssRes = (0, css_1.transform)({
+                filename: path.relative(this.rootContext, this.resourcePath),
+                code: content instanceof Buffer ? content : Buffer.from(content),
+                // minify: this.mode === 'production',
+                cssModules: needToUseIcssPlugin,
+                analyzeDependencies: true,
+                sourceMap: options.sourceMap,
+                drafts: {
+                    nesting: true,
+                    customMedia: true
+                },
+                pseudoClasses: {},
+                targets: browsersTargets
+            });
+            if (options.sourceMap && map) {
+                ParcelCssRes.map = (0, utils_1.normalizeSourceMap)(map, this.resourcePath);
+            }
+        }
+        catch (error) {
+            console.error('-> error', error);
+            if (callback) {
+                callback(error.name === 'SyntaxError' ? new CssSyntaxError_1.default(error) : error);
+            }
+            return;
+        }
+        const { dependencies = [] } = ParcelCssRes;
+        const parcelImportsMap = new Map();
+        const parcelUrlsMap = new Map();
+        const icssMap = new Map();
+        const parcelReplacementsMap = new Map();
+        const parcelImports = [];
+        const parcelApis = [];
+        const parcelReplacements = [];
+        const parcelExports = [];
+        let hasUrlImportHelper = false;
+        for (let index = 0; index < dependencies.length; index++) {
+            const dep = dependencies[index];
+            let { type, url } = dep;
+            const dataUrl = (0, utils_1.isDataUrl)(url);
+            url = (0, utils_1.normalizeUrl)(url, !dataUrl);
+            url = url.trim();
+            if (url.length === 0) {
+                // Empty url - `@import "";` or `@import url();`
+                console.error("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.");
+                continue;
+            }
+            if (type === 'import') {
+                const { supports, media } = dep;
+                const { requestable, needResolve } = (0, utils_1.isURLRequestable)(url, {
+                    isSupportAbsoluteURL: false,
+                    isSupportDataURL: false
+                });
+                let prefix;
+                if (requestable && needResolve) {
+                    const queryParts = url.split('!');
+                    if (queryParts.length > 1) {
+                        url = queryParts.pop();
+                        prefix = queryParts.join('!');
+                    }
+                }
+                const resolver = this.getResolve({
+                    dependencyType: 'css',
+                    conditionNames: ['style'],
+                    mainFields: ['css', 'style', 'main', '...'],
+                    mainFiles: ['index', '...'],
+                    extensions: ['.css', '...'],
+                    preferRelative: true
+                });
+                if (needResolve) {
+                    const request = (0, utils_1.requestify)(url, this.rootContext);
+                    const resolvedUrl = yield (0, utils_1.resolveRequests)(resolver, this.context, [
+                        ...new Set([request, url])
+                    ]);
+                    if (!resolvedUrl) {
+                        continue;
+                    }
+                    if (resolvedUrl === this.resourcePath) {
+                        continue;
+                    }
+                    url = resolvedUrl;
+                }
+                if (!requestable) {
+                    parcelApis.push({
+                        url,
+                        layer: undefined,
+                        supports,
+                        media,
+                        index
+                    });
+                    continue;
+                }
+                url = prefix ? `${prefix}!${url}` : url;
+                let importName = parcelImportsMap.get(url);
+                if (!importName) {
+                    const { size } = parcelImportsMap;
+                    importName = `___CSS_LOADER_AT_RULE_IMPORT_${size}___`;
+                    parcelImportsMap.set(url, importName);
+                    parcelImports.push({
+                        type: 'rule_import',
+                        importName,
+                        url: (0, utils_1.stringifyRequest)(this, (0, utils_1.combineRequests)((0, utils_1.getPreRequester)(this)(options.importLoaders), url)),
+                        index: size
+                    });
+                }
+                parcelApis.push({
+                    importName,
+                    layer: undefined,
+                    supports,
+                    media,
+                    index
+                });
+            }
+            else if (type === 'url') {
+                const { placeholder } = dep;
+                const { requestable, needResolve } = (0, utils_1.isURLRequestable)(url, {
+                    isSupportAbsoluteURL,
+                    isSupportDataURL
+                });
+                // console.log("-> url6 6", url, requestable, needResolve);
+                // Do not traverse inside `url`
+                if (!requestable && !needResolve) {
+                    if (!parcelReplacementsMap.get(url)) {
+                        parcelReplacementsMap.set(url, placeholder);
+                        parcelReplacements.push({
+                            placeholder,
+                            replacementName: url,
+                            hash: undefined,
+                            needQuotes: false,
+                            isString: true
+                        });
+                    }
+                    continue;
+                }
+                const queryParts = url.split('!');
+                let prefix;
+                if (queryParts.length > 1) {
+                    url = queryParts.pop();
+                    prefix = queryParts.join('!');
+                }
+                const splittedUrl = url.split(/(\?)?#/);
+                const [pathname, query, hashOrQuery] = splittedUrl;
+                let hash = query ? '?' : '';
+                hash += hashOrQuery ? `#${hashOrQuery}` : '';
+                const resolver = !options.esModule
+                    ? this.getResolve({ mainFiles: [], extensions: [] })
+                    : undefined;
+                const request = (0, utils_1.requestify)(pathname, this.rootContext, Boolean(resolver));
+                if (!resolver) {
+                    // eslint-disable-next-line consistent-return
+                    url = request;
+                }
+                else {
+                    const resolvedURL = yield (0, utils_1.resolveRequests)(resolver, this.context, [
+                        ...new Set([request, url])
+                    ]);
+                    if (resolvedURL) {
+                        url = resolvedURL;
+                    }
+                }
+                if (!hasUrlImportHelper) {
+                    parcelImports.push({
+                        type: 'get_url_import',
+                        importName: '___CSS_LOADER_GET_URL_IMPORT___',
+                        url: (0, utils_1.stringifyRequest)(this, require.resolve('./runtime/getUrl.js')),
+                        index: -1
+                    });
+                    hasUrlImportHelper = true;
+                }
+                url = prefix ? `${prefix}!${url}` : url;
+                let importName = parcelUrlsMap.get(url);
+                if (!importName) {
+                    importName = `___CSS_LOADER_URL_IMPORT_${parcelUrlsMap.size}___`;
+                    parcelUrlsMap.set(url, importName);
+                    parcelImports.push({
+                        // type: 'url',
+                        importName,
+                        url: (0, utils_1.stringifyRequest)(this, url),
+                        index
+                    });
+                    parcelReplacements.push({
+                        placeholder,
+                        replacementName: `___CSS_LOADER_URL_REPLACEMENT_${index}___`,
+                        importName,
+                        hash,
+                        needQuotes: false,
+                        isString: false
+                    });
+                }
+            }
+        }
+        if (ParcelCssRes.exports) {
+            const resolver = this.getResolve({
+                dependencyType: 'icss',
+                conditionNames: ['style'],
+                extensions: ['...'],
+                mainFields: ['css', 'style', 'main', '...'],
+                mainFiles: ['index', '...'],
+                preferRelative: true
+            });
+            const exportKeys = Object.keys(ParcelCssRes.exports);
+            for (const exportKey of exportKeys) {
+                const exportItem = ParcelCssRes.exports[exportKey];
+                const { name, composes } = exportItem;
+                let value = name;
+                for (const compose of composes) {
+                    const { type } = compose;
+                    if (['global', 'local'].includes(type)) {
+                        value += ` ${compose.name}`;
+                    }
+                    if (type === 'dependency') {
+                        let url = compose.specifier;
+                        let prefix = '';
+                        const queryParts = url.split('!');
+                        if (queryParts.length > 1) {
+                            url = queryParts.pop();
+                            prefix = queryParts.join('!');
+                        }
+                        const request = (0, utils_1.requestify)((0, utils_1.normalizeUrl)(url, true), this.rootContext);
+                        const resolvedUrl = yield (0, utils_1.resolveRequests)(resolver, this.context, [
+                            ...new Set([url, request])
+                        ]);
+                        if (!resolvedUrl) {
+                            continue;
+                        }
+                        url = resolvedUrl;
+                        url = prefix ? `${prefix}!${url}` : url;
+                        let importName = icssMap.get(url);
+                        if (!importName) {
+                            const index = icssMap.size;
+                            importName = `___CSS_LOADER_ICSS_IMPORT_${index}___`;
+                            icssMap.set(url, importName);
+                            parcelImports.push({
+                                type: 'icss_import',
+                                importName,
+                                url: (0, utils_1.stringifyRequest)(this, (0, utils_1.combineRequests)((0, utils_1.getPreRequester)(this)(options.importLoaders), url)),
+                                icss: true,
+                                index
+                            });
+                            parcelApis.push({ importName, dedupe: true, index });
+                        }
+                        const replacementName = `___REPLACEMENT_${parcelReplacements.length}_${importName}`;
+                        parcelReplacements.push({
+                            localName: compose.name,
+                            replacementName,
+                            importName
+                        });
+                        value += ` ${replacementName}`;
+                    }
+                }
+                parcelExports.push({
+                    name: exportKey,
+                    value
+                });
+            }
+        }
+        if (options.modules.exportOnlyLocals !== true) {
+            parcelImports.unshift({
+                type: 'api_import',
+                importName: '___CSS_LOADER_API_IMPORT___',
+                url: (0, utils_1.stringifyRequest)(this, require.resolve('./runtime/api'))
+            });
+            if (options.sourceMap) {
+                parcelImports.unshift({
+                    importName: '___CSS_LOADER_API_SOURCEMAP_IMPORT___',
+                    url: (0, utils_1.stringifyRequest)(this, require.resolve('./runtime/sourceMaps'))
+                });
+            }
+            else {
+                parcelImports.unshift({
+                    importName: '___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___',
+                    url: (0, utils_1.stringifyRequest)(this, require.resolve('./runtime/noSourceMaps'))
+                });
+            }
+        }
+        parcelImportsMap.clear();
+        parcelUrlsMap.clear();
+        icssMap.clear();
+        parcelReplacementsMap.clear();
+        const importCode = (0, utils_1.getImportCode)(parcelImports, options);
+        let moduleCode;
+        try {
+            moduleCode = (0, utils_1.getParcelCssModuleCode)(ParcelCssRes, parcelApis, parcelReplacements, options, this);
+        }
+        catch (error) {
+            if (callback) {
+                callback(error);
+            }
+            return;
+        }
+        const exportCode = (0, utils_1.getExportCode)(parcelExports, parcelReplacements, needToUseIcssPlugin, options);
+        const resultCode = `${importCode}${moduleCode}${exportCode}`;
+        if (callback) {
+            callback(null, resultCode);
+        }
+    });
+}
+exports.default = loader;
+// accept Buffers instead of strings
+exports.raw = true;

package/lib/webpack/loaders/parcel-css-loader/runtime/api.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(cssWithMappingToString: any): any[];
+export = _exports;

package/lib/webpack/loaders/parcel-css-loader/runtime/api.js

@@ -0,0 +1,85 @@
+"use strict";
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+module.exports = cssWithMappingToString => {
+    const list = [];
+    // return the list of modules as css string
+    list.toString = function toString() {
+        return this.map(item => {
+            let content = '';
+            const needLayer = typeof item[5] !== 'undefined';
+            if (item[4]) {
+                content += `@supports (${item[4]}) {`;
+            }
+            if (item[2]) {
+                content += `@media ${item[2]} {`;
+            }
+            if (needLayer) {
+                content += `@layer${item[5].length > 0 ? ` ${item[5]}` : ''} {`;
+            }
+            content += cssWithMappingToString(item);
+            if (needLayer) {
+                content += '}';
+            }
+            if (item[2]) {
+                content += '}';
+            }
+            if (item[4]) {
+                content += '}';
+            }
+            return content;
+        }).join('');
+    };
+    // import a list of modules into the list
+    list.i = function i(modules, media, dedupe, supports, layer) {
+        if (typeof modules === 'string') {
+            modules = [[null, modules, undefined]];
+        }
+        const alreadyImportedModules = {};
+        if (dedupe) {
+            for (let k = 0; k < this.length; k++) {
+                const id = this[k][0];
+                if (id != null) {
+                    alreadyImportedModules[id] = true;
+                }
+            }
+        }
+        for (let k = 0; k < modules.length; k++) {
+            const item = [].concat(modules[k]);
+            if (dedupe && alreadyImportedModules[item[0]]) {
+                continue;
+            }
+            if (typeof layer !== 'undefined') {
+                if (typeof item[5] === 'undefined') {
+                    item[5] = layer;
+                }
+                else {
+                    item[1] = `@layer${item[5].length > 0 ? ` ${item[5]}` : ''} {${item[1]}}`;
+                    item[5] = layer;
+                }
+            }
+            if (media) {
+                if (!item[2]) {
+                    item[2] = media;
+                }
+                else {
+                    item[1] = `@media ${item[2]} {${item[1]}}`;
+                    item[2] = media;
+                }
+            }
+            if (supports) {
+                if (!item[4]) {
+                    item[4] = `${supports}`;
+                }
+                else {
+                    item[1] = `@supports (${item[4]}) {${item[1]}}`;
+                    item[4] = supports;
+                }
+            }
+            list.push(item);
+        }
+    };
+    return list;
+};

package/lib/webpack/loaders/parcel-css-loader/runtime/getUrl.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(url: any, options: any): any;
+export = _exports;

package/lib/webpack/loaders/parcel-css-loader/runtime/getUrl.js

@@ -0,0 +1,23 @@
+"use strict";
+module.exports = (url, options) => {
+    if (!options) {
+        options = {};
+    }
+    if (!url) {
+        return url;
+    }
+    url = String(url.__esModule ? url.default : url);
+    // If url is already wrapped in quotes, remove them
+    if (/^['"].*['"]$/.test(url)) {
+        url = url.slice(1, -1);
+    }
+    if (options.hash) {
+        url += options.hash;
+    }
+    // Should url be wrapped?
+    // See https://drafts.csswg.org/css-values-3/#urls
+    if (/["'() \t\n]|(%20)/.test(url) || options.needQuotes) {
+        return `"${url.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
+    }
+    return url;
+};

package/lib/webpack/loaders/parcel-css-loader/runtime/noSourceMaps.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(i: any): any;
+export = _exports;

package/lib/webpack/loaders/parcel-css-loader/runtime/noSourceMaps.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = i => i[1];

package/lib/webpack/loaders/parcel-css-loader/runtime/sourceMaps.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(item: any): any;
+export = _exports;

package/lib/webpack/loaders/parcel-css-loader/runtime/sourceMaps.js

@@ -0,0 +1,16 @@
+"use strict";
+module.exports = item => {
+    const content = item[1];
+    const cssMapping = item[3];
+    if (!cssMapping) {
+        return content;
+    }
+    if (typeof btoa === 'function') {
+        const base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+        const data = `sourceMappingURL=data:application/json;charset=utf-8;base64,${base64}`;
+        const sourceMapping = `/*# ${data} */`;
+        const sourceURLs = cssMapping.sources.map(source => `/*# sourceURL=${cssMapping.sourceRoot || ''}${source} */`);
+        return [content].concat(sourceURLs).concat([sourceMapping]).join('\n');
+    }
+    return [content].join('\n');
+};

package/lib/webpack/loaders/parcel-css-loader/utils.d.ts

@@ -0,0 +1,28 @@
+export function normalizeOptions(rawOptions: any, loaderContext: any): {
+    url: any;
+    import: any;
+    modules: any;
+    sourceMap: any;
+    importLoaders: any;
+    esModule: any;
+    exportType: any;
+};
+export function shouldUseIcssPlugin(options: any): boolean;
+export function normalizeUrl(url: any, isStringValue: any): any;
+export function requestify(url: any, rootContext: any, needToResolveURL?: boolean): any;
+export function normalizeSourceMap(map: any, resourcePath: any): any;
+export function getPreRequester({ loaders, loaderIndex }: {
+    loaders: any;
+    loaderIndex: any;
+}): (number: any) => any;
+export function getImportCode(imports: any, options: any): string;
+export function getParcelCssModuleCode(result: any, api: any, replacements: any, options: any, loaderContext: any): string;
+export function getExportCode(exports: any, replacements: any, icssPluginUsed: any, options: any): string;
+export function resolveRequests(resolve: any, context: any, possibleRequests: any): Promise<any>;
+export function isURLRequestable(url: any, options?: {}): {
+    requestable: boolean;
+    needResolve: boolean;
+};
+export function combineRequests(preRequest: any, url: any): any;
+export function stringifyRequest(loaderContext: any, request: any): string;
+export function isDataUrl(url: any): boolean;