@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/lib/preprocess/lib/preprocess.js

@@ -0,0 +1,437 @@
+/*
+ * preprocess
+ * https://github.com/onehealth/preprocess
+ *
+ * Copyright (c) 2012 OneHealth Solutions, Inc.
+ * Written by Jarrod Overson - http://jarrodoverson.com/
+ * Licensed under the Apache 2.0 license.
+ */
+
+'use strict';
+
+exports.preprocess         = preprocess;
+exports.preprocessFile     = preprocessFile;
+exports.preprocessFileSync = preprocessFileSync;
+
+var path  = require('path'),
+    fs    = require('fs'),
+    os    = require('os'),
+    delim = require('./regexrules'),
+    XRegExp = require('xregexp');
+
+function preprocessFile(srcFile, destFile, context, callback, options) {
+  options = getOptionsForFile(srcFile, options);
+  context.src = srcFile;
+
+  fs.readFile(srcFile, function (err, data) {
+    if (err) return callback(err, data);
+    var parsed = preprocess(data, context, options);
+    fs.writeFile(destFile, parsed, callback);
+  });
+}
+
+function preprocessFileSync(srcFile, destFile, context, options) {
+  options = getOptionsForFile(srcFile, options);
+  context.src = srcFile;
+
+  var data = fs.readFileSync(srcFile);
+  var parsed = preprocess(data, context, options);
+  return fs.writeFileSync(destFile, parsed);
+}
+
+function getOptionsForFile(srcFile, options) {
+  options = options || {};
+  options.srcDir = options.srcDir || path.dirname(srcFile);
+  options.type = options.type || getExtension(srcFile);
+
+  return options;
+}
+
+function getExtension(filename) {
+  var ext = path.extname(filename||'').split('.');
+  return ext[ext.length - 1];
+}
+
+function preprocess(src, context, typeOrOptions) {
+  src = src.toString();
+  context = context || process.env;
+
+  // default values
+  var options = {
+    fileNotFoundSilentFail: false,
+    srcDir: process.cwd(),
+    srcEol: getEolType(src),
+    type: delim['html']
+  };
+
+  // needed for backward compatibility with 2.x.x series
+  if (typeof typeOrOptions === 'string') {
+    typeOrOptions = {
+      type: typeOrOptions
+    };
+  }
+
+  // needed for backward compatibility with 2.x.x series
+  if (typeof context.srcDir === "string") {
+    typeOrOptions = typeOrOptions || {};
+    typeOrOptions.srcDir = context.srcDir;
+  }
+
+  if (typeOrOptions && typeof typeOrOptions === 'object') {
+    options.srcDir = typeOrOptions.srcDir || options.srcDir;
+    options.fileNotFoundSilentFail = typeOrOptions.fileNotFoundSilentFail || options.fileNotFoundSilentFail;
+    options.srcEol = typeOrOptions.srcEol || options.srcEol;
+    options.type = delim[typeOrOptions.type] || options.type;
+  }
+
+  context = copy(context);
+
+  return preprocessor(src, context, options);
+}
+
+function preprocessor(src, context, opts, noRestoreEol) {
+  src = normalizeEol(src);
+
+  var rv = src;
+
+  rv = replace(rv, opts.type.include, processIncludeDirective.bind(null, false, context, opts));
+
+  if (opts.type.extend) {
+    rv = replaceRecursive(rv, opts.type.extend, function(startMatches, endMatches, include, recurse) {
+      var file = (startMatches[1] || '').trim();
+      var extendedContext = copy(context);
+      var extendedOpts = copy(opts);
+      extendedContext.src = path.join(opts.srcDir, file);
+      extendedOpts.srcDir = path.dirname(extendedContext.src);
+
+      var fileContents = getFileContents(extendedContext.src, opts.fileNotFoundSilentFail, context.src);
+      if (fileContents.error) {
+        return fileContents.contents;
+      }
+
+      var extendedSource = preprocessor(fileContents.contents, extendedContext, extendedOpts, true).trim();
+
+      if (extendedSource) {
+        include = include.replace(/^\n?|\n?$/g, '');
+        return replace(extendedSource, opts.type.extendable, recurse(include));
+      } else {
+        return '';
+      }
+    });
+  }
+
+  if (opts.type.foreach) {
+    rv = replaceRecursive(rv, opts.type.foreach, function(startMatches, endMatches, include, recurse) {
+      var variable = (startMatches[1] || '').trim();
+      var forParams = variable.split(' ');
+      if (forParams.length === 3) {
+        var contextVar = forParams[2];
+        var arrString = getDeepPropFromObj(context, contextVar);
+        var eachArr;
+        if (arrString.match(/\{(.*)\}/)) {
+          eachArr = JSON.parse(arrString);
+        } else if (arrString.match(/\[(.*)\]/)) {
+          eachArr = arrString.slice(1, -1);
+          eachArr = eachArr.split(',');
+          eachArr = eachArr.map(function(arrEntry){
+            return arrEntry.replace(/\s*(['"])(.*)\1\s*/, '$2');
+          });
+        } else {
+          eachArr = arrString.split(',');
+        }
+
+        var replaceToken = new RegExp(XRegExp.escape(forParams[0]), 'g');
+        var recursedInclude = recurse(include);
+
+        return Object.keys(eachArr).reduce(function(stringBuilder, arrKey){
+          var arrEntry = eachArr[arrKey];
+          return stringBuilder + recursedInclude.replace(replaceToken, arrEntry);
+        }, '');
+      } else {
+        return '';
+      }
+    });
+  }
+
+  if (opts.type.exclude) {
+    rv = replaceRecursive(rv, opts.type.exclude, function(startMatches, endMatches, include, recurse){
+      var test = (startMatches[1] || '').trim();
+      return testPasses(test,context) ? '' : recurse(include);
+    });
+  }
+
+  if (opts.type.if) {
+    rv = replaceRecursive(rv, opts.type.if, function (startMatches, endMatches, include, recurse) {
+	  // I need to recurse first, so I don't catch "inner" else-directives
+      var recursed = recurse(include);
+      
+	  // look for the first else-directive
+	  var matches = opts.type.else && recursed.match(new RegExp(opts.type.else));
+      var match = (matches || [""])[0];
+      var index = match ? recursed.indexOf(match) : recursed.length;
+	  
+      var ifBlock = recursed.substring(0, index);
+      var elseBlock = recursed.substring(index + match.length); // empty string if no else-directive
+	  
+      var variant = startMatches[1];
+      var test = (startMatches[2] || '').trim();
+      // fixed by xxxxxx
+      var startLine = padContent(startMatches.input)
+      var endLine = padContent(endMatches.input)
+      switch(variant) {
+        case 'if':
+        case 'ifdef': // fixed by xxxxxx
+          return testPasses(test, context) ? (startLine + ifBlock + endLine) : (startLine + padContent(ifBlock) + padContent(match || '') + elseBlock + endLine);
+        case 'ifndef':
+          return !testPasses(test, context) ? (startLine + ifBlock + endLine) : (startLine + padContent(ifBlock) + padContent(match || '') + elseBlock + endLine);
+        // case 'ifdef':
+        //   return typeof getDeepPropFromObj(context, test) !== 'undefined' ? ifBlock : elseBlock;
+        // case 'ifndef':
+        //   return typeof getDeepPropFromObj(context, test) === 'undefined' ? ifBlock : elseBlock;
+        default:
+          throw new Error('Unknown if variant ' + variant + '.');
+      }
+    });
+  }
+
+  rv = replace(rv, opts.type.echo, function (match, variable) {
+    variable = (variable || '').trim();
+    // if we are surrounded by quotes, echo as a string
+    var stringMatch = variable.match(/^(['"])(.*)\1$/);
+    if (stringMatch) return stringMatch[2];
+
+    var arrString = getDeepPropFromObj(context, variable);
+    return typeof arrString !== 'undefined' ? arrString : '';
+  });
+
+  rv = replace(rv, opts.type.exec, function (match, name, value) {
+    name = (name || '').trim();
+    value = value || '';
+
+    var params = value.split(',');
+    var stringRegex = /^['"](.*)['"]$/;
+
+    params = params.map(function(param){
+      param = param.trim();
+      if (stringRegex.test(param)) { // handle string parameter
+        return param.replace(stringRegex, '$1');
+      } else { // handle variable parameter
+        return getDeepPropFromObj(context, param);
+      }
+    });
+
+    var fn = getDeepPropFromObj(context, name);
+    if (!fn || typeof fn !== 'function') return '';
+
+    return fn.apply(context, params);
+  });
+
+  rv = replace(rv, opts.type['include-static'], processIncludeDirective.bind(null, true, context, opts));
+
+  if (!noRestoreEol) {
+    rv = restoreEol(rv, opts.srcEol);
+  }
+
+  return rv;
+}
+
+function getEolType(source) {
+  var eol;
+  var foundEolTypeCnt = 0;
+
+  if (source.indexOf('\r\n') >= 0) {
+    eol = '\r\n';
+    foundEolTypeCnt++;
+  }
+  if (/\r[^\n]/.test(source)) {
+    eol = '\r';
+    foundEolTypeCnt++;
+  }
+  if (/[^\r]\n/.test(source)) {
+    eol = '\n';
+    foundEolTypeCnt++;
+  }
+
+  if (eol == null || foundEolTypeCnt > 1) {
+    eol = os.EOL;
+  }
+
+  return eol;
+}
+
+function normalizeEol(source, indent) {
+  // only process any kind of EOL if indentation has to be added, otherwise replace only non \n EOLs
+  if (indent) {
+    source = source.replace(/(?:\r?\n)|\r/g, '\n' + indent);
+  } else {
+    source = source.replace(/(?:\r\n)|\r/g, '\n');
+  }
+
+  return source;
+}
+
+function restoreEol(normalizedSource, originalEol) {
+  if (originalEol !== '\n') {
+    normalizedSource = normalizedSource.replace(/\n/g, originalEol);
+  }
+
+  return normalizedSource;
+}
+
+function replace(rv, rule, processor) {
+  var isRegex = typeof rule === 'string' || rule instanceof RegExp;
+  var isArray = Array.isArray(rule);
+
+  if (isRegex) {
+    rule = [new RegExp(rule,'gmi')];
+  } else if (isArray) {
+    rule = rule.map(function(subRule){
+      return new RegExp(subRule,'gmi');
+    });
+  } else {
+    throw new Error('Rule must be a String, a RegExp, or an Array.');
+  }
+
+  return rule.reduce(function(rv, rule){
+    return rv.replace(rule, processor);
+  }, rv);
+}
+
+function replaceRecursive(rv, rule, processor) {
+  if(!rule.start || !rule.end) {
+    throw new Error('Recursive rule must have start and end.');
+  }
+
+  var startRegex = new RegExp(rule.start, 'mi');
+  var endRegex = new RegExp(rule.end, 'mi');
+
+  function matchReplacePass(content) {
+    var matches = XRegExp.matchRecursive(content, rule.start, rule.end, 'gmi', {
+      valueNames: ['between', 'left', 'match', 'right']
+    });
+
+    var matchGroup = {
+      left: null,
+      match: null,
+      right: null
+    };
+
+    return matches.reduce(function (builder, match) {
+      switch(match.name) {
+        case 'between':
+          builder += match.value;
+          break;
+        case 'left':
+          matchGroup.left = startRegex.exec(match.value);
+          break;
+        case 'match':
+          matchGroup.match = match.value;
+          break;
+        case 'right':
+          matchGroup.right = endRegex.exec(match.value);
+          builder += processor(matchGroup.left, matchGroup.right, matchGroup.match, matchReplacePass);
+          break;
+      }
+      return builder;
+    }, '');
+  }
+
+  return matchReplacePass(rv);
+}
+
+
+function processIncludeDirective(isStatic, context, opts, match, linePrefix, file) {
+  file = (file || '').trim();
+  var indent = linePrefix.replace(/\S/g, ' ');
+  var includedContext = copy(context);
+  var includedOpts = copy(opts);
+  includedContext.src = path.join(opts.srcDir,file);
+  includedOpts.srcDir = path.dirname(includedContext.src);
+
+  var fileContents = getFileContents(includedContext.src, opts.fileNotFoundSilentFail, context.src);
+  if (fileContents.error) {
+    return linePrefix + fileContents.contents;
+  }
+
+  var includedSource = fileContents.contents;
+  if (isStatic) {
+    includedSource = fileContents.contents;
+  } else {
+    includedSource = preprocessor(fileContents.contents, includedContext, includedOpts, true);
+  }
+
+  includedSource = normalizeEol(includedSource, indent);
+
+  if (includedSource) {
+    return linePrefix + includedSource;
+  } else {
+    return linePrefix;
+  }
+}
+
+function getTestTemplate(test) {
+  /*jshint evil:true*/
+  test = test || 'true';
+  test = test.trim();
+
+  // force single equals replacement
+  test = test.replace(/([^=!])=([^=])/g, '$1==$2');
+  // fixed by xxxxxx
+  test = test.replace(/-/g, '_')
+  return new Function("context", "with (context||{}){ return ( " + test + " ); }");
+}
+
+// fixed by xxxxxx
+function testPasses(test, context) {
+  var testFn = getTestTemplate(test)
+  try {
+    return testFn(context, getDeepPropFromObj)
+  } catch (e) {}
+  return false
+}
+
+function getFileContents(path, failSilent, requesterPath) {
+  try {
+    fs.statSync(path);
+  } catch (e) {
+    if (failSilent) {
+      return {error: true, contents: path + ' not found!'};
+    } else {
+      var errMsg = path;
+      errMsg = requesterPath ? errMsg + ' requested from ' + requesterPath : errMsg;
+      errMsg += ' not found!';
+      throw new Error(errMsg);
+    }
+  }
+  return {error: false, contents: fs.readFileSync(path).toString()};
+}
+
+function copy(obj) {
+  return Object.keys(obj).reduce(function (copyObj, objKey) {
+    copyObj[objKey] = obj[objKey];
+    return copyObj;
+  }, {});
+}
+
+function getDeepPropFromObj(obj, propPath) {
+  propPath.replace(/\[([^\]+?])\]/g, '.$1');
+  propPath = propPath.split('.');
+
+  // fast path, no need to loop if structurePath contains only a single segment
+  if (propPath.length === 1) {
+    return obj[propPath[0]];
+  }
+
+  // loop only as long as possible (no exceptions for null/undefined property access)
+  propPath.some(function (pathSegment) {
+    obj = obj[pathSegment];
+    return (obj == null);
+  });
+
+  return obj;
+}
+// fixed by xxxxxx
+const splitRE = /\r?\n/g
+function padContent(content) {
+  return Array(content.split(splitRE).length).join('\n')
+}

package/lib/preprocess/lib/regexrules.js

@@ -0,0 +1,121 @@
+
+module.exports = {
+  simple : {
+    echo : "^#echo[ \t]+(.*?)[ \t]*$",
+    exec : "^#exec[ \t]+(\\S+)[ \t]*\\((.*)\\)[ \t]*$",
+    include          : "^(.*)#include(?!-)[ \t]+(.*?)[ \t]*$", // allow prefix characters to specify the indent level of included file
+    'include-static' : "^(.*)#include-static[ \t]+(.*?)[ \t]*$"
+  },
+  html : {
+    echo : "<!--[ \t]*#echo[ \t]+(.*?)[ \t]*(?:-->|!>)",
+    exec : "<!--[ \t]*#exec[ \t]+(\\S+)[ \t]*\\((.*)\\)[ \t]*(?:-->|!>)",
+    include          : "(.*)<!--[ \t]*#include(?!-)[ \t]+(.*?)[ \t]*(?:-->|!>)",
+    'include-static' : "(.*)<!--[ \t]*#include-static[ \t]+(.*?)[ \t]*(?:-->|!>)",
+    exclude : {
+      start : "[ \t]*<!--[ \t]*#exclude(?:[ \t]+(.*?))?[ \t]*(?:-->|!>)(?:[ \t]*\n+)?",
+      end   : "[ \t]*<!--[ \t]*#endexclude[ \t]*(?:-->|!>)(?:[ \t]*\n)?"
+    },
+    extend : {
+      start : "[ \t]*<!--[ \t]*#extend(?!able)[ \t]+(.*?)[ \t]*(?:-->|!>)(?:[ \t]*\n+)?",
+      end   : "[ \t]*<!--[ \t]*#endextend[ \t]*(?:-->|!>)(?:[ \t]*\n)?"
+    },
+    extendable : "<!--[ \t]*#extendable[ \t]*(?:-->|!>)",
+    if : {
+      start : "[ \t]*<!--[ \t]*#(ifndef|ifdef|if)[ \t]+(.*?)[ \t]*(?:-->|!>)(?:[ \t]*\n+)?",
+      end   : "[ \t]*<!(?:--)?[ \t]*#endif[ \t]*(?:-->|!>)(?:[ \t]*\n)?"
+    },
+    else : "[ \t]*<!(?:--)?[ \t]*#else[ \t]*(?:-->|!>)(?:[ \t]*\n)?",
+    foreach : {
+      start : "[ \t]*<!--[ \t]*#foreach[ \t]+(.*?)[ \t]*(?:-->|!>)(?:[ \t]*\n+)?",
+      end   : "[ \t]*<!(?:--)?[ \t]*#endfor[ \t]*(?:-->|!>)(?:[ \t]*\n)?"
+    }
+  },
+  js : {
+    echo : [
+      "/\\*[ \t]*#echo[ \t]+(.*?)[ \t]*\\*(?:\\*|/)",
+      "//[ \t]*#echo[ \t]+(.*?)[ \t]*$"
+    ],
+    exec : "(?://|/\\*)[ \t]*#exec[ \t]+(\\S+?)[ \t]*\\((.*)\\)[ \t]*(?:\\*(?:\\*|/))?",
+    include : [
+      "^(.*)/\\*[ \t]*#include(?!-)[ \t]+(.*?)[ \t]*\\*(?:\\*|/)",
+      "^(.*)//[ \t]*#include(?!-)[ \t]+(.*?)[ \t]*$"
+    ],
+    'include-static': [
+      "^(.*)/\\*[ \t]*#include-static[ \t]+(.*?)[ \t]*\\*(?:\\*|/)",
+      "^(.*)//[ \t]*#include-static[ \t]+(.*?)[ \t]*$"
+    ],
+    exclude : {
+      start : "[ \t]*(?://|/\\*)[ \t]*#exclude(?:[ \t]+([^\n*]*))?[ \t]*(?:\\*(?:\\*|/))?(?:[ \t]*\n+)?",
+      end   : "[ \t]*(?://|/\\*)[ \t]*#endexclude[ \t]*(?:\\*(?:\\*|/))?(?:[ \t]*\n)?"
+    },
+    extend : {
+      start : "[ \t]*(?://|/\\*)[ \t]*#extend(?!able)[ \t]+([^\n*]*)(?:\\*(?:\\*|/))?(?:[ \t]*\n+)?",
+      end   : "[ \t]*(?://|/\\*)[ \t]*#endextend[ \t]*(?:\\*(?:\\*|/))?(?:[ \t]*\n)?"
+    },
+    extendable : "[ \t]*(?://|/\\*)[ \t]*#extendable[ \t]*(?:\\*/)?",
+    if : {
+      start : "[ \t]*(?://|/\\*)[ \t]*#(ifndef|ifdef|if)[ \t]+([^\n*]*)(?:\\*(?:\\*|/))?(?:[ \t]*\n+)?",
+      end   : "[ \t]*(?://|/\\*)[ \t]*#endif[ \t]*(?:\\*(?:\\*|/))?(?:[ \t]*\n)?"
+    },
+    else : "[ \t]*(?://|/\\*)[ \t]*#else[ \t]*(?:\\*(?:\\*|/))?(?:[ \t]*\n)?",
+    foreach : {
+      start : "[ \t]*(?://|/\\*)[ \t]*#foreach[ \t]+([^\n*]*)(?:\\*(?:\\*|/))?(?:[ \t]*\n+)?",
+      end   : "[ \t]*(?://|/\\*)[ \t]*#endfor[ \t]*(?:\\*(?:\\*|/))?(?:[ \t]*\n)?"
+    }
+  },
+  coffee : {
+    echo : [
+      "###+[ \t]*#echo[ \t]+(.*?)[ \t]###",
+      "#+[ \t]*#echo[ \t]+(.*?)[ \t]*$"
+    ],
+    exec : "#+[ \t]*#exec[ \t]+(\\S+)[ \t]*\\((.*)\\)[ \t]*$",
+    include          : "^(.*?)#+[ \t]*#include(?!-)[ \t]+(.*?)[ \t]*$",
+    'include-static' : "^(.*?)#+[ \t]*#include-static[ \t]+(.*?)[ \t]*$",
+    exclude : {
+      start : "^[ \t]*#+[ \t]*#exclude(?:[ \t]+(.*?))?[ \t]*\n+",
+      end   : "^[ \t]*#+[ \t]*#endexclude[ \t]*\n?"
+    },
+    extend : {
+      start : "^[ \t]*#+[ \t]*#extend(?!able)[ \t]+(.*?)\n+",
+      end   : "^[ \t]*#+[ \t]*#endextend[ \t]*\n?"
+    },
+    extendable : "^[ \t]*#+[ \t]*#extendable[ \t]*$",
+    if : {
+      start : "^[ \t]*#+[ \t]*#(ifndef|ifdef|if)[ \t]+(.*?)[ \t]*\n+",
+      end   : "^[ \t]*#+[ \t]*#endif[ \t]*\n?"
+    },
+    else : "^[ \t]*#+[ \t]*#else[ \t]*\n?",
+    foreach : {
+      start : "^[ \t]*#+[ \t]*#foreach[ \t]+(.*?)[ \t]*\n+",
+      end   : "^[ \t]*#+[ \t]*#endfor[ \t]*\n?"
+    }
+  }
+};
+
+module.exports.xml        = module.exports.html;
+
+module.exports.javascript = module.exports.js;
+module.exports.jsx        = module.exports.js;
+module.exports.json       = module.exports.js;
+module.exports.c          = module.exports.js;
+module.exports.cc         = module.exports.js;
+module.exports.cpp        = module.exports.js;
+module.exports.cs         = module.exports.js;
+module.exports.csharp     = module.exports.js;
+module.exports.java       = module.exports.js;
+module.exports.less       = module.exports.js;
+module.exports.sass       = module.exports.js;
+module.exports.scss       = module.exports.js;
+module.exports.css        = module.exports.js;
+module.exports.php        = module.exports.js;
+module.exports.ts         = module.exports.js;
+module.exports.tsx        = module.exports.js;
+module.exports.peg        = module.exports.js;
+module.exports.pegjs      = module.exports.js;
+module.exports.jade       = module.exports.js;
+module.exports.styl       = module.exports.js;
+module.exports.go         = module.exports.js;
+
+module.exports.bash       = module.exports.coffee;
+module.exports.shell      = module.exports.coffee;
+module.exports.sh         = module.exports.coffee;

package/lib/preprocess/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "preprocess",
+  "description": "Preprocess directives in HTML, JavaScript, etc directives based off variable context",
+  "version": "3.2.0",
+  "homepage": "https://github.com/jsoverson/preprocess",
+  "author": {
+    "name": "Jarrod Overson",
+    "email": "jsoverson@gmail.com",
+    "url": "http://jarrodoverson.com/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jsoverson/preprocess.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jsoverson/preprocess/issues"
+  },
+  "licenses": [
+    {
+      "type": "Apache 2.0",
+      "url": "https://github.com/jsoverson/preprocess/blob/master/LICENSE"
+    }
+  ],
+  "main": "lib/preprocess.js",
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "scripts": {
+    "test": "grunt test",
+    "ci": "grunt ci"
+  },
+  "dependencies": {
+    "xregexp": "3.1.0"
+  },
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "chai-spies": "^0.7.0",
+    "grunt": "^0.4.5",
+    "grunt-benchmark": "^0.3.0",
+    "grunt-cli": "^0.1.13",
+    "grunt-contrib-clean": "^1.0.0",
+    "grunt-contrib-copy": "^0.8.0",
+    "grunt-contrib-jshint": "^1.0.0",
+    "grunt-contrib-watch": "^0.6.1",
+    "grunt-coveralls": "^1.0.0",
+    "grunt-deps-ok": "^0.9.0",
+    "grunt-mocha-istanbul": "^3.0.1",
+    "grunt-mocha-test": "^0.12.7",
+    "istanbul": "^0.4.2",
+    "load-grunt-tasks": "^3.4.0",
+    "mocha": "^2.4.5",
+    "time-grunt": "^1.3.0",
+    "travis-cov": "^0.2.5"
+  },
+  "keywords": [
+    "directive",
+    "ENV",
+    "environment",
+    "ifdef",
+    "ifndef",
+    "echo",
+    "include",
+    "exclude",
+    "process",
+    "preprocess",
+    "pragma"
+  ]
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@dcloudio/uni-cli-shared",
+  "version": "0.0.1-nvue3.3030820220125001",
+  "description": "@dcloudio/uni-cli-shared",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-cli-shared"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/dcloudio/uni-app/issues"
+  },
+  "dependencies": {
+    "@babel/core": "^7.16.5",
+    "@babel/parser": "^7.16.4",
+    "@babel/types": "^7.16.0",
+    "@dcloudio/uni-i18n": "0.0.1-nvue3.3030820220125001",
+    "@dcloudio/uni-shared": "0.0.1-nvue3.3030820220125001",
+    "@rollup/pluginutils": "^4.1.2",
+    "@vue/compiler-core": "3.2.29",
+    "@vue/compiler-dom": "3.2.29",
+    "@vue/compiler-sfc": "3.2.29",
+    "@vue/server-renderer": "3.2.29",
+    "@vue/shared": "3.2.29",
+    "autoprefixer": "^10.4.2",
+    "base64url": "^3.0.1",
+    "chokidar": "^3.5.2",
+    "compare-versions": "^3.6.0",
+    "debug": "^4.3.2",
+    "es-module-lexer": "^0.9.3",
+    "esbuild": "^0.13.12",
+    "estree-walker": "^2.0.2",
+    "fast-glob": "^3.2.7",
+    "fs-extra": "^10.0.0",
+    "hash-sum": "^2.0.0",
+    "jsonc-parser": "^3.0.0",
+    "magic-string": "^0.25.7",
+    "merge": "^2.1.1",
+    "mime": "^3.0.0",
+    "module-alias": "^2.2.2",
+    "picocolors": "^1.0.0",
+    "postcss-import": "^14.0.2",
+    "postcss-load-config": "^3.1.0",
+    "postcss-modules": "^4.2.2",
+    "postcss-selector-parser": "^6.0.6",
+    "resolve": "^1.20.0",
+    "tapable": "^2.2.0",
+    "xregexp": "3.1.0"
+  },
+  "gitHead": "33e807d66e1fe47e2ee08ad9c59247e37b8884da",
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/fs-extra": "^9.0.13",
+    "@types/hash-sum": "^1.0.0",
+    "@types/less": "^3.0.3",
+    "@types/mime": "^2.0.3",
+    "@types/module-alias": "^2.0.1",
+    "@types/stylus": "^0.48.36",
+    "postcss": "^8.4.5"
+  }
+}