first commit

app_vue/node_modules/css-loader/dist/plugins/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "icssParser", {
+  enumerable: true,
+  get: function () {
+    return _postcssIcssParser.default;
+  }
+});
+Object.defineProperty(exports, "importParser", {
+  enumerable: true,
+  get: function () {
+    return _postcssImportParser.default;
+  }
+});
+Object.defineProperty(exports, "urlParser", {
+  enumerable: true,
+  get: function () {
+    return _postcssUrlParser.default;
+  }
+});
+var _postcssImportParser = _interopRequireDefault(require("./postcss-import-parser"));
+var _postcssIcssParser = _interopRequireDefault(require("./postcss-icss-parser"));
+var _postcssUrlParser = _interopRequireDefault(require("./postcss-url-parser"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

app_vue/node_modules/css-loader/dist/plugins/postcss-icss-parser.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _icssUtils = require("icss-utils");
+var _utils = require("../utils");
+const plugin = (options = {}) => {
+  return {
+    postcssPlugin: "postcss-icss-parser",
+    async OnceExit(root) {
+      const importReplacements = Object.create(null);
+      const {
+        icssImports,
+        icssExports
+      } = (0, _icssUtils.extractICSS)(root);
+      const imports = new Map();
+      const tasks = [];
+      const {
+        loaderContext
+      } = options;
+      const resolver = loaderContext.getResolve({
+        dependencyType: "icss",
+        conditionNames: ["style"],
+        extensions: ["..."],
+        mainFields: ["css", "style", "main", "..."],
+        mainFiles: ["index", "..."],
+        preferRelative: true
+      });
+
+      // eslint-disable-next-line guard-for-in
+      for (const url in icssImports) {
+        const tokens = icssImports[url];
+        if (Object.keys(tokens).length === 0) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+        let normalizedUrl = url;
+        let prefix = "";
+        const queryParts = normalizedUrl.split("!");
+        if (queryParts.length > 1) {
+          normalizedUrl = queryParts.pop();
+          prefix = queryParts.join("!");
+        }
+        const request = (0, _utils.requestify)((0, _utils.normalizeUrl)(normalizedUrl, true), loaderContext.rootContext);
+        const doResolve = async () => {
+          const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([normalizedUrl, request])]);
+          if (!resolvedUrl) {
+            return;
+          }
+
+          // eslint-disable-next-line consistent-return
+          return {
+            url: resolvedUrl,
+            prefix,
+            tokens
+          };
+        };
+        tasks.push(doResolve());
+      }
+      const results = await Promise.all(tasks);
+      for (let index = 0; index <= results.length - 1; index++) {
+        const item = results[index];
+        if (!item) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+        const newUrl = item.prefix ? `${item.prefix}!${item.url}` : item.url;
+        const importKey = newUrl;
+        let importName = imports.get(importKey);
+        if (!importName) {
+          importName = `___CSS_LOADER_ICSS_IMPORT_${imports.size}___`;
+          imports.set(importKey, importName);
+          options.imports.push({
+            type: "icss_import",
+            importName,
+            url: options.urlHandler(newUrl),
+            icss: true,
+            index
+          });
+          options.api.push({
+            importName,
+            dedupe: true,
+            index
+          });
+        }
+        for (const [replacementIndex, token] of Object.keys(item.tokens).entries()) {
+          const replacementName = `___CSS_LOADER_ICSS_IMPORT_${index}_REPLACEMENT_${replacementIndex}___`;
+          const localName = item.tokens[token];
+          importReplacements[token] = replacementName;
+          options.replacements.push({
+            replacementName,
+            importName,
+            localName
+          });
+        }
+      }
+      if (Object.keys(importReplacements).length > 0) {
+        (0, _icssUtils.replaceSymbols)(root, importReplacements);
+      }
+      for (const name of Object.keys(icssExports)) {
+        const value = (0, _icssUtils.replaceValueSymbols)(icssExports[name], importReplacements);
+        options.exports.push({
+          name,
+          value
+        });
+      }
+    }
+  };
+};
+plugin.postcss = true;
+var _default = exports.default = plugin;

app_vue/node_modules/css-loader/dist/plugins/postcss-import-parser.js

@@ -0,0 +1,282 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function parseNode(atRule, key, options) {
+  // Convert only top-level @import
+  if (atRule.parent.type !== "root") {
+    return;
+  }
+  if (atRule.raws && atRule.raws.afterName && atRule.raws.afterName.trim().length > 0) {
+    const lastCommentIndex = atRule.raws.afterName.lastIndexOf("/*");
+    const matched = atRule.raws.afterName.slice(lastCommentIndex).match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+    if (matched && matched[2] === "true") {
+      return;
+    }
+  }
+  const prevNode = atRule.prev();
+  if (prevNode && prevNode.type === "comment") {
+    const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+    if (matched && matched[2] === "true") {
+      return;
+    }
+  }
+
+  // Nodes do not exists - `@import url('http://') :root {}`
+  if (atRule.nodes) {
+    const error = new Error("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.");
+    error.node = atRule;
+    throw error;
+  }
+  const rawParams = atRule.raws && atRule.raws[key] && typeof atRule.raws[key].raw !== "undefined" ? atRule.raws[key].raw : atRule[key];
+  const {
+    nodes: paramsNodes
+  } = (0, _postcssValueParser.default)(rawParams);
+
+  // No nodes - `@import ;`
+  // Invalid type - `@import foo-bar;`
+  if (paramsNodes.length === 0 || paramsNodes[0].type !== "string" && paramsNodes[0].type !== "function") {
+    const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+    error.node = atRule;
+    throw error;
+  }
+  let isStringValue;
+  let url;
+  if (paramsNodes[0].type === "string") {
+    isStringValue = true;
+    url = paramsNodes[0].value;
+  } else {
+    // Invalid function - `@import nourl(test.css);`
+    if (paramsNodes[0].value.toLowerCase() !== "url") {
+      const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+      error.node = atRule;
+      throw error;
+    }
+    isStringValue = paramsNodes[0].nodes.length !== 0 && paramsNodes[0].nodes[0].type === "string";
+    url = isStringValue ? paramsNodes[0].nodes[0].value : _postcssValueParser.default.stringify(paramsNodes[0].nodes);
+  }
+  url = (0, _utils.normalizeUrl)(url, isStringValue);
+  const {
+    requestable,
+    needResolve
+  } = (0, _utils.isURLRequestable)(url, options);
+  let prefix;
+  if (requestable && needResolve) {
+    const queryParts = url.split("!");
+    if (queryParts.length > 1) {
+      url = queryParts.pop();
+      prefix = queryParts.join("!");
+    }
+  }
+
+  // Empty url - `@import "";` or `@import url();`
+  if (url.trim().length === 0) {
+    const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+    error.node = atRule;
+    throw error;
+  }
+  const additionalNodes = paramsNodes.slice(1);
+  let supports;
+  let layer;
+  let media;
+  if (additionalNodes.length > 0) {
+    let nodes = [];
+    for (const node of additionalNodes) {
+      nodes.push(node);
+      const isLayerFunction = node.type === "function" && node.value.toLowerCase() === "layer";
+      const isLayerWord = node.type === "word" && node.value.toLowerCase() === "layer";
+      if (isLayerFunction || isLayerWord) {
+        if (isLayerFunction) {
+          nodes.splice(nodes.length - 1, 1, ...node.nodes);
+        } else {
+          nodes.splice(nodes.length - 1, 1, {
+            type: "string",
+            value: "",
+            unclosed: false
+          });
+        }
+        layer = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+        nodes = [];
+      } else if (node.type === "function" && node.value.toLowerCase() === "supports") {
+        nodes.splice(nodes.length - 1, 1, ...node.nodes);
+        supports = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+        nodes = [];
+      }
+    }
+    if (nodes.length > 0) {
+      media = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+    }
+  }
+
+  // eslint-disable-next-line consistent-return
+  return {
+    atRule,
+    prefix,
+    url,
+    layer,
+    supports,
+    media,
+    requestable,
+    needResolve
+  };
+}
+const plugin = (options = {}) => {
+  return {
+    postcssPlugin: "postcss-import-parser",
+    prepare(result) {
+      const parsedAtRules = [];
+      return {
+        AtRule: {
+          import(atRule) {
+            if (options.isCSSStyleSheet) {
+              options.loaderContext.emitError(new Error(atRule.error("'@import' rules are not allowed here and will not be processed").message));
+              return;
+            }
+            const {
+              isSupportDataURL,
+              isSupportAbsoluteURL
+            } = options;
+            let parsedAtRule;
+            try {
+              parsedAtRule = parseNode(atRule, "params", {
+                isSupportAbsoluteURL,
+                isSupportDataURL
+              });
+            } catch (error) {
+              result.warn(error.message, {
+                node: error.node
+              });
+            }
+            if (!parsedAtRule) {
+              return;
+            }
+            parsedAtRules.push(parsedAtRule);
+          }
+        },
+        async OnceExit() {
+          if (parsedAtRules.length === 0) {
+            return;
+          }
+          const {
+            loaderContext
+          } = options;
+          const resolver = loaderContext.getResolve({
+            dependencyType: "css",
+            conditionNames: ["style"],
+            mainFields: ["css", "style", "main", "..."],
+            mainFiles: ["index", "..."],
+            extensions: [".css", "..."],
+            preferRelative: true
+          });
+          const resolvedAtRules = await Promise.all(parsedAtRules.map(async parsedAtRule => {
+            const {
+              atRule,
+              requestable,
+              needResolve,
+              prefix,
+              url,
+              layer,
+              supports,
+              media
+            } = parsedAtRule;
+            if (options.filter) {
+              const needKeep = await options.filter(url, media, loaderContext.resourcePath, supports, layer);
+              if (!needKeep) {
+                return;
+              }
+            }
+            if (needResolve) {
+              const request = (0, _utils.requestify)(url, loaderContext.rootContext);
+              const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([request, url])]);
+              if (!resolvedUrl) {
+                return;
+              }
+              if (resolvedUrl === loaderContext.resourcePath) {
+                atRule.remove();
+                return;
+              }
+              atRule.remove();
+
+              // eslint-disable-next-line consistent-return
+              return {
+                url: resolvedUrl,
+                layer,
+                supports,
+                media,
+                prefix,
+                requestable
+              };
+            }
+            atRule.remove();
+
+            // eslint-disable-next-line consistent-return
+            return {
+              url,
+              layer,
+              supports,
+              media,
+              prefix,
+              requestable
+            };
+          }));
+          const urlToNameMap = new Map();
+          for (let index = 0; index <= resolvedAtRules.length - 1; index++) {
+            const resolvedAtRule = resolvedAtRules[index];
+            if (!resolvedAtRule) {
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+            const {
+              url,
+              requestable,
+              layer,
+              supports,
+              media
+            } = resolvedAtRule;
+            if (!requestable) {
+              options.api.push({
+                url,
+                layer,
+                supports,
+                media,
+                index
+              });
+
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+            const {
+              prefix
+            } = resolvedAtRule;
+            const newUrl = prefix ? `${prefix}!${url}` : url;
+            let importName = urlToNameMap.get(newUrl);
+            if (!importName) {
+              importName = `___CSS_LOADER_AT_RULE_IMPORT_${urlToNameMap.size}___`;
+              urlToNameMap.set(newUrl, importName);
+              options.imports.push({
+                type: "rule_import",
+                importName,
+                url: options.urlHandler(newUrl),
+                index
+              });
+            }
+            options.api.push({
+              importName,
+              layer,
+              supports,
+              media,
+              index
+            });
+          }
+        }
+      };
+    }
+  };
+};
+plugin.postcss = true;
+var _default = exports.default = plugin;

app_vue/node_modules/css-loader/dist/plugins/postcss-url-parser.js

@@ -0,0 +1,356 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+var _utils = require("../utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const isUrlFunc = /url/i;
+const isImageSetFunc = /^(?:-webkit-)?image-set$/i;
+const needParseDeclaration = /(?:url|(?:-webkit-)?image-set)\(/i;
+function getNodeFromUrlFunc(node) {
+  return node.nodes && node.nodes[0];
+}
+function getWebpackIgnoreCommentValue(index, nodes, inBetween) {
+  if (index === 0 && typeof inBetween !== "undefined") {
+    return inBetween;
+  }
+  let prevValueNode = nodes[index - 1];
+  if (!prevValueNode) {
+    // eslint-disable-next-line consistent-return
+    return;
+  }
+  if (prevValueNode.type === "space") {
+    if (!nodes[index - 2]) {
+      // eslint-disable-next-line consistent-return
+      return;
+    }
+    prevValueNode = nodes[index - 2];
+  }
+  if (prevValueNode.type !== "comment") {
+    // eslint-disable-next-line consistent-return
+    return;
+  }
+  const matched = prevValueNode.value.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+  return matched && matched[2] === "true";
+}
+function shouldHandleURL(url, declaration, result, options) {
+  if (url.length === 0) {
+    result.warn(`Unable to find uri in '${declaration.toString()}'`, {
+      node: declaration
+    });
+    return {
+      requestable: false,
+      needResolve: false
+    };
+  }
+  return (0, _utils.isURLRequestable)(url, options);
+}
+function parseDeclaration(declaration, key, result, options) {
+  if (!needParseDeclaration.test(declaration[key])) {
+    return;
+  }
+  const parsed = (0, _postcssValueParser.default)(declaration.raws && declaration.raws.value && declaration.raws.value.raw ? declaration.raws.value.raw : declaration[key]);
+  let inBetween;
+  if (declaration.raws && declaration.raws.between) {
+    const lastCommentIndex = declaration.raws.between.lastIndexOf("/*");
+    const matched = declaration.raws.between.slice(lastCommentIndex).match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+    if (matched) {
+      inBetween = matched[2] === "true";
+    }
+  }
+  let isIgnoreOnDeclaration = false;
+  const prevNode = declaration.prev();
+  if (prevNode && prevNode.type === "comment") {
+    const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+    if (matched) {
+      isIgnoreOnDeclaration = matched[2] === "true";
+    }
+  }
+  let needIgnore;
+  const parsedURLs = [];
+  parsed.walk((valueNode, index, valueNodes) => {
+    if (valueNode.type !== "function") {
+      return;
+    }
+    if (isUrlFunc.test(valueNode.value)) {
+      needIgnore = getWebpackIgnoreCommentValue(index, valueNodes, inBetween);
+      if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+        if (needIgnore) {
+          // eslint-disable-next-line no-undefined
+          needIgnore = undefined;
+        }
+        return;
+      }
+      const {
+        nodes
+      } = valueNode;
+      const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+      let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
+      url = (0, _utils.normalizeUrl)(url, isStringValue);
+      const {
+        requestable,
+        needResolve
+      } = shouldHandleURL(url, declaration, result, options);
+
+      // Do not traverse inside `url`
+      if (!requestable) {
+        // eslint-disable-next-line consistent-return
+        return false;
+      }
+      const queryParts = url.split("!");
+      let prefix;
+      if (queryParts.length > 1) {
+        url = queryParts.pop();
+        prefix = queryParts.join("!");
+      }
+      parsedURLs.push({
+        declaration,
+        parsed,
+        node: getNodeFromUrlFunc(valueNode),
+        prefix,
+        url,
+        needQuotes: false,
+        needResolve
+      });
+
+      // eslint-disable-next-line consistent-return
+      return false;
+    } else if (isImageSetFunc.test(valueNode.value)) {
+      for (const [innerIndex, nNode] of valueNode.nodes.entries()) {
+        const {
+          type,
+          value
+        } = nNode;
+        if (type === "function" && isUrlFunc.test(value)) {
+          needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+          if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+            if (needIgnore) {
+              // eslint-disable-next-line no-undefined
+              needIgnore = undefined;
+            }
+
+            // eslint-disable-next-line no-continue
+            continue;
+          }
+          const {
+            nodes
+          } = nNode;
+          const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+          let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
+          url = (0, _utils.normalizeUrl)(url, isStringValue);
+          const {
+            requestable,
+            needResolve
+          } = shouldHandleURL(url, declaration, result, options);
+
+          // Do not traverse inside `url`
+          if (!requestable) {
+            // eslint-disable-next-line consistent-return
+            return false;
+          }
+          const queryParts = url.split("!");
+          let prefix;
+          if (queryParts.length > 1) {
+            url = queryParts.pop();
+            prefix = queryParts.join("!");
+          }
+          parsedURLs.push({
+            declaration,
+            parsed,
+            node: getNodeFromUrlFunc(nNode),
+            prefix,
+            url,
+            needQuotes: false,
+            needResolve
+          });
+        } else if (type === "string") {
+          needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+          if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+            if (needIgnore) {
+              // eslint-disable-next-line no-undefined
+              needIgnore = undefined;
+            }
+
+            // eslint-disable-next-line no-continue
+            continue;
+          }
+          let url = (0, _utils.normalizeUrl)(value, true);
+          const {
+            requestable,
+            needResolve
+          } = shouldHandleURL(url, declaration, result, options);
+
+          // Do not traverse inside `url`
+          if (!requestable) {
+            // eslint-disable-next-line consistent-return
+            return false;
+          }
+          const queryParts = url.split("!");
+          let prefix;
+          if (queryParts.length > 1) {
+            url = queryParts.pop();
+            prefix = queryParts.join("!");
+          }
+          parsedURLs.push({
+            declaration,
+            parsed,
+            node: nNode,
+            prefix,
+            url,
+            needQuotes: true,
+            needResolve
+          });
+        }
+      }
+
+      // Do not traverse inside `image-set`
+      // eslint-disable-next-line consistent-return
+      return false;
+    }
+  });
+
+  // eslint-disable-next-line consistent-return
+  return parsedURLs;
+}
+const plugin = (options = {}) => {
+  return {
+    postcssPlugin: "postcss-url-parser",
+    prepare(result) {
+      const parsedDeclarations = [];
+      return {
+        Declaration(declaration) {
+          const {
+            isSupportDataURL,
+            isSupportAbsoluteURL
+          } = options;
+          const parsedURL = parseDeclaration(declaration, "value", result, {
+            isSupportDataURL,
+            isSupportAbsoluteURL
+          });
+          if (!parsedURL) {
+            return;
+          }
+          parsedDeclarations.push(...parsedURL);
+        },
+        async OnceExit() {
+          if (parsedDeclarations.length === 0) {
+            return;
+          }
+          const resolvedDeclarations = await Promise.all(parsedDeclarations.map(async parsedDeclaration => {
+            const {
+              url,
+              needResolve
+            } = parsedDeclaration;
+            if (options.filter) {
+              const needKeep = await options.filter(url);
+              if (!needKeep) {
+                // eslint-disable-next-line consistent-return
+                return;
+              }
+            }
+            if (!needResolve) {
+              // eslint-disable-next-line consistent-return
+              return parsedDeclaration;
+            }
+            const splittedUrl = url.split(/(\?)?#/);
+            const [pathname, query, hashOrQuery] = splittedUrl;
+            let hash = query ? "?" : "";
+            hash += hashOrQuery ? `#${hashOrQuery}` : "";
+            const {
+              resolver,
+              rootContext
+            } = options;
+            const request = (0, _utils.requestify)(pathname, rootContext, Boolean(resolver));
+            if (!resolver) {
+              // eslint-disable-next-line consistent-return
+              return {
+                ...parsedDeclaration,
+                url: request,
+                hash
+              };
+            }
+            const resolvedURL = await (0, _utils.resolveRequests)(resolver, options.context, [...new Set([request, url])]);
+            if (!resolvedURL) {
+              // eslint-disable-next-line consistent-return
+              return;
+            }
+
+            // eslint-disable-next-line consistent-return
+            return {
+              ...parsedDeclaration,
+              url: resolvedURL,
+              hash
+            };
+          }));
+          const urlToNameMap = new Map();
+          const urlToReplacementMap = new Map();
+          let hasUrlImportHelper = false;
+          for (let index = 0; index <= resolvedDeclarations.length - 1; index++) {
+            const item = resolvedDeclarations[index];
+            if (!item) {
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+            if (!hasUrlImportHelper) {
+              options.imports.push({
+                type: "get_url_import",
+                importName: "___CSS_LOADER_GET_URL_IMPORT___",
+                url: options.urlHandler(require.resolve("../runtime/getUrl.js")),
+                index: -1
+              });
+              hasUrlImportHelper = true;
+            }
+            const {
+              url,
+              prefix
+            } = item;
+            const newUrl = prefix ? `${prefix}!${url}` : url;
+            let importName = urlToNameMap.get(newUrl);
+            if (!importName) {
+              importName = `___CSS_LOADER_URL_IMPORT_${urlToNameMap.size}___`;
+              urlToNameMap.set(newUrl, importName);
+              options.imports.push({
+                type: "url",
+                importName,
+                url: options.resolver ? options.urlHandler(newUrl) : JSON.stringify(newUrl),
+                index
+              });
+            }
+            const {
+              hash,
+              needQuotes
+            } = item;
+            const replacementKey = JSON.stringify({
+              newUrl,
+              hash,
+              needQuotes
+            });
+            let replacementName = urlToReplacementMap.get(replacementKey);
+            if (!replacementName) {
+              replacementName = `___CSS_LOADER_URL_REPLACEMENT_${urlToReplacementMap.size}___`;
+              urlToReplacementMap.set(replacementKey, replacementName);
+              options.replacements.push({
+                replacementName,
+                importName,
+                hash,
+                needQuotes
+              });
+            }
+
+            // eslint-disable-next-line no-param-reassign
+            item.node.type = "word";
+            // eslint-disable-next-line no-param-reassign
+            item.node.value = replacementName;
+            // eslint-disable-next-line no-param-reassign
+            item.declaration.value = item.parsed.toString();
+          }
+        }
+      };
+    }
+  };
+};
+plugin.postcss = true;
+var _default = exports.default = plugin;