vite 2.9.0-beta.1 → 2.9.0-beta.10

package/dist/node/chunks/{dep-1cf708c4.js → dep-a96b376f.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./dep-62435a6f.js');
+var index = require('./dep-7a52803b.js');
 var require$$1 = require('crypto');
 require('fs');
 require('path');
@@ -19,9 +19,9 @@ require('https');
 require('zlib');
 require('tls');
 require('assert');
+require('esbuild');
 require('buffer');
 require('querystring');
-require('esbuild');
 require('child_process');
 require('worker_threads');
 require('readline');
@@ -2936,6 +2936,10 @@ _IN('1.3.14.3.2.29', 'sha1WithRSASignature');
 _IN('2.16.840.1.101.3.4.2.1', 'sha256');
 _IN('2.16.840.1.101.3.4.2.2', 'sha384');
 _IN('2.16.840.1.101.3.4.2.3', 'sha512');
+_IN('2.16.840.1.101.3.4.2.4', 'sha224');
+_IN('2.16.840.1.101.3.4.2.5', 'sha512-224');
+_IN('2.16.840.1.101.3.4.2.6', 'sha512-256');
+_IN('1.2.840.113549.2.2', 'md2');
 _IN('1.2.840.113549.2.5', 'md5');
 
 // pkcs#7 content types
@@ -3477,6 +3481,8 @@ var _getValueLength = function(bytes, remaining) {
  * @param [options] object with options or boolean strict flag
  *          [strict] true to be strict when checking value lengths, false to
  *            allow truncated values (default: true).
+ *          [parseAllBytes] true to ensure all bytes are parsed
+ *            (default: true)
  *          [decodeBitStrings] true to attempt to decode the content of
  *            BIT STRINGs (not OCTET STRINGs) using strict mode. Note that
  *            without schema support to understand the data context this can
@@ -3484,24 +3490,31 @@ var _getValueLength = function(bytes, remaining) {
  *            flag will be deprecated or removed as soon as schema support is
  *            available. (default: true)
  *
+ * @throws Will throw an error for various malformed input conditions.
+ *
  * @return the parsed asn1 object.
  */
 asn1$6.fromDer = function(bytes, options) {
   if(options === undefined) {
     options = {
       strict: true,
+      parseAllBytes: true,
       decodeBitStrings: true
     };
   }
   if(typeof options === 'boolean') {
     options = {
       strict: options,
+      parseAllBytes: true,
       decodeBitStrings: true
     };
   }
   if(!('strict' in options)) {
     options.strict = true;
   }
+  if(!('parseAllBytes' in options)) {
+    options.parseAllBytes = true;
+  }
   if(!('decodeBitStrings' in options)) {
     options.decodeBitStrings = true;
   }
@@ -3511,7 +3524,15 @@ asn1$6.fromDer = function(bytes, options) {
     bytes = forge$p.util.createBuffer(bytes);
   }
 
-  return _fromDer(bytes, bytes.length(), 0, options);
+  var byteCount = bytes.length();
+  var value = _fromDer(bytes, bytes.length(), 0, options);
+  if(options.parseAllBytes && bytes.length() !== 0) {
+    var error = new Error('Unparsed DER bytes remain after ASN.1 parsing.');
+    error.byteCount = byteCount;
+    error.remaining = bytes.length();
+    throw error;
+  }
+  return value;
 };
 
 /**
@@ -3632,7 +3653,6 @@ function _fromDer(bytes, remaining, depth, options) {
         start = bytes.length();
         var subOptions = {
           // enforce strict mode to avoid parsing ASN.1 from plain data
-          verbose: options.verbose,
           strict: true,
           decodeBitStrings: true
         };
@@ -3681,6 +3701,7 @@ function _fromDer(bytes, remaining, depth, options) {
       }
     } else {
       value = bytes.getBytes(length);
+      remaining -= length;
     }
   }
 
@@ -4456,7 +4477,16 @@ asn1$6.prettyPrint = function(obj, level, indentation) {
       }
       rval += '0x' + forge$p.util.bytesToHex(obj.value);
     } else if(obj.type === asn1$6.Type.UTF8) {
-      rval += forge$p.util.decodeUtf8(obj.value);
+      try {
+        rval += forge$p.util.decodeUtf8(obj.value);
+      } catch(e) {
+        if(e.message === 'URI malformed') {
+          rval +=
+            '0x' + forge$p.util.bytesToHex(obj.value) + ' (malformed UTF8)';
+        } else {
+          throw e;
+        }
+      }
     } else if(obj.type === asn1$6.Type.PRINTABLESTRING ||
       obj.type === asn1$6.Type.IA5String) {
       rval += obj.value;
@@ -11668,6 +11698,40 @@ var publicKeyValidator$1 = forge$8.pki.rsa.publicKeyValidator = {
   }]
 };
 
+// validator for a DigestInfo structure
+var digestInfoValidator = {
+  name: 'DigestInfo',
+  tagClass: asn1$5.Class.UNIVERSAL,
+  type: asn1$5.Type.SEQUENCE,
+  constructed: true,
+  value: [{
+    name: 'DigestInfo.DigestAlgorithm',
+    tagClass: asn1$5.Class.UNIVERSAL,
+    type: asn1$5.Type.SEQUENCE,
+    constructed: true,
+    value: [{
+      name: 'DigestInfo.DigestAlgorithm.algorithmIdentifier',
+      tagClass: asn1$5.Class.UNIVERSAL,
+      type: asn1$5.Type.OID,
+      constructed: false,
+      capture: 'algorithmIdentifier'
+    }, {
+      // NULL paramters
+      name: 'DigestInfo.DigestAlgorithm.parameters',
+      tagClass: asn1$5.Class.UNIVERSAL,
+      type: asn1$5.Type.NULL,
+      constructed: false
+    }]
+  }, {
+    // digest
+    name: 'DigestInfo.digest',
+    tagClass: asn1$5.Class.UNIVERSAL,
+    type: asn1$5.Type.OCTETSTRING,
+    constructed: false,
+    capture: 'digest'
+  }]
+};
+
 /**
  * Wrap digest in DigestInfo object.
  *
@@ -12496,15 +12560,27 @@ pki$4.setRsaPublicKey = pki$4.rsa.setPublicKey = function(n, e) {
    *          a Forge PSS object for RSASSA-PSS,
    *          'NONE' or null for none, DigestInfo will not be expected, but
    *            PKCS#1 v1.5 padding will still be used.
+   * @param options optional verify options
+   *          _parseAllDigestBytes testing flag to control parsing of all
+   *            digest bytes. Unsupported and not for general usage.
+   *            (default: true)
    *
    * @return true if the signature was verified, false if not.
    */
-  key.verify = function(digest, signature, scheme) {
+  key.verify = function(digest, signature, scheme, options) {
     if(typeof scheme === 'string') {
       scheme = scheme.toUpperCase();
     } else if(scheme === undefined) {
       scheme = 'RSASSA-PKCS1-V1_5';
     }
+    if(options === undefined) {
+      options = {
+        _parseAllDigestBytes: true
+      };
+    }
+    if(!('_parseAllDigestBytes' in options)) {
+      options._parseAllDigestBytes = true;
+    }
 
     if(scheme === 'RSASSA-PKCS1-V1_5') {
       scheme = {
@@ -12512,9 +12588,41 @@ pki$4.setRsaPublicKey = pki$4.rsa.setPublicKey = function(n, e) {
           // remove padding
           d = _decodePkcs1_v1_5(d, key, true);
           // d is ASN.1 BER-encoded DigestInfo
-          var obj = asn1$5.fromDer(d);
+          var obj = asn1$5.fromDer(d, {
+            parseAllBytes: options._parseAllDigestBytes
+          });
+
+          // validate DigestInfo
+          var capture = {};
+          var errors = [];
+          if(!asn1$5.validate(obj, digestInfoValidator, capture, errors)) {
+            var error = new Error(
+              'ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 ' +
+              'DigestInfo value.');
+            error.errors = errors;
+            throw error;
+          }
+          // check hash algorithm identifier
+          // see PKCS1-v1-5DigestAlgorithms in RFC 8017
+          // FIXME: add support to vaidator for strict value choices
+          var oid = asn1$5.derToOid(capture.algorithmIdentifier);
+          if(!(oid === forge$8.oids.md2 ||
+            oid === forge$8.oids.md5 ||
+            oid === forge$8.oids.sha1 ||
+            oid === forge$8.oids.sha224 ||
+            oid === forge$8.oids.sha256 ||
+            oid === forge$8.oids.sha384 ||
+            oid === forge$8.oids.sha512 ||
+            oid === forge$8.oids['sha512-224'] ||
+            oid === forge$8.oids['sha512-256'])) {
+            var error = new Error(
+              'Unknown RSASSA-PKCS1-v1_5 DigestAlgorithm identifier.');
+            error.oid = oid;
+            throw error;
+          }
+
           // compare the given digest to the decrypted one
-          return digest === obj.value[1].value;
+          return digest === capture.digest;
         }
       };
     } else if(scheme === 'NONE' || scheme === 'NULL' || scheme === null) {

package/dist/node/chunks/{dep-ec2e68f4.js → dep-bcc0af00.js}

@@ -39,6 +39,14 @@ var joinMedia$1 = function (parentMedia, childMedia) {
   return media
 };
 
+var joinLayer$1 = function (parentLayer, childLayer) {
+  if (!parentLayer.length && childLayer.length) return childLayer
+  if (parentLayer.length && !childLayer.length) return parentLayer
+  if (!parentLayer.length && !childLayer.length) return []
+
+  return parentLayer.concat(childLayer)
+};
+
 // external tooling
 const resolve$1 = resolve__default;
 
@@ -330,6 +338,7 @@ var parseStatements$1 = function (result, styles) {
           type: "nodes",
           nodes,
           media: [],
+          layer: [],
         });
         nodes = [];
       }
@@ -342,6 +351,7 @@ var parseStatements$1 = function (result, styles) {
       type: "nodes",
       nodes,
       media: [],
+      layer: [],
     });
   }
 
@@ -354,6 +364,7 @@ function parseMedia(result, atRule) {
     type: "media",
     node: atRule,
     media: split(params, 0),
+    layer: [],
   }
 }
 
@@ -367,6 +378,7 @@ function parseCharset(result, atRule) {
     type: "charset",
     node: atRule,
     media: [],
+    layer: [],
   }
 }
 
@@ -377,10 +389,12 @@ function parseImport(result, atRule) {
       if (
         prev.type !== "comment" &&
         (prev.type !== "atrule" ||
-          (prev.name !== "import" && prev.name !== "charset"))
+          (prev.name !== "import" &&
+            prev.name !== "charset" &&
+            !(prev.name === "layer" && !prev.nodes)))
       ) {
         return result.warn(
-          "@import must precede all other statements (besides @charset)",
+          "@import must precede all other statements (besides @charset or empty @layer)",
           { node: atRule }
         )
       }
@@ -401,6 +415,7 @@ function parseImport(result, atRule) {
     type: "import",
     node: atRule,
     media: [],
+    layer: [],
   };
 
   // prettier-ignore
@@ -426,11 +441,31 @@ function parseImport(result, atRule) {
   else stmt.uri = params[0].nodes[0].value;
   stmt.fullUri = stringify(params[0]);
 
-  if (params.length > 2) {
-    if (params[1].type !== "space") {
+  let remainder = params;
+  if (remainder.length > 2) {
+    if (
+      (remainder[2].type === "word" || remainder[2].type === "function") &&
+      remainder[2].value === "layer"
+    ) {
+      if (remainder[1].type !== "space") {
+        return result.warn("Invalid import layer statement", { node: atRule })
+      }
+
+      if (remainder[2].nodes) {
+        stmt.layer = [stringify(remainder[2].nodes)];
+      } else {
+        stmt.layer = [""];
+      }
+      remainder = remainder.slice(2);
+    }
+  }
+
+  if (remainder.length > 2) {
+    if (remainder[1].type !== "space") {
       return result.warn("Invalid import media statement", { node: atRule })
     }
-    stmt.media = split(params, 2);
+
+    stmt.media = split(remainder, 2);
   }
 
   return stmt
@@ -441,6 +476,7 @@ const path = path__default;
 
 // internal tooling
 const joinMedia = joinMedia$1;
+const joinLayer = joinLayer$1;
 const resolveId = resolveId$1;
 const loadContent = loadContent$1;
 const processContent = processContent$1;
@@ -483,11 +519,13 @@ function AtImport(options) {
         throw new Error("plugins option must be an array")
       }
 
-      return parseStyles(result, styles, options, state, []).then(bundle => {
-        applyRaws(bundle);
-        applyMedia(bundle);
-        applyStyles(bundle, styles);
-      })
+      return parseStyles(result, styles, options, state, [], []).then(
+        bundle => {
+          applyRaws(bundle);
+          applyMedia(bundle);
+          applyStyles(bundle, styles);
+        }
+      )
 
       function applyRaws(bundle) {
         bundle.forEach((stmt, index) => {
@@ -505,21 +543,60 @@ function AtImport(options) {
 
       function applyMedia(bundle) {
         bundle.forEach(stmt => {
-          if (!stmt.media.length || stmt.type === "charset") return
+          if (
+            (!stmt.media.length && !stmt.layer.length) ||
+            stmt.type === "charset"
+          ) {
+            return
+          }
+
           if (stmt.type === "import") {
             stmt.node.params = `${stmt.fullUri} ${stmt.media.join(", ")}`;
-          } else if (stmt.type === "media")
+          } else if (stmt.type === "media") {
             stmt.node.params = stmt.media.join(", ");
-          else {
+          } else {
             const { nodes } = stmt;
             const { parent } = nodes[0];
-            const mediaNode = atRule({
-              name: "media",
-              params: stmt.media.join(", "),
-              source: parent.source,
-            });
 
-            parent.insertBefore(nodes[0], mediaNode);
+            let outerAtRule;
+            let innerAtRule;
+            if (stmt.media.length && stmt.layer.length) {
+              const mediaNode = atRule({
+                name: "media",
+                params: stmt.media.join(", "),
+                source: parent.source,
+              });
+
+              const layerNode = atRule({
+                name: "layer",
+                params: stmt.layer.filter(layer => layer !== "").join("."),
+                source: parent.source,
+              });
+
+              mediaNode.append(layerNode);
+              innerAtRule = layerNode;
+              outerAtRule = mediaNode;
+            } else if (stmt.media.length) {
+              const mediaNode = atRule({
+                name: "media",
+                params: stmt.media.join(", "),
+                source: parent.source,
+              });
+
+              innerAtRule = mediaNode;
+              outerAtRule = mediaNode;
+            } else if (stmt.layer.length) {
+              const layerNode = atRule({
+                name: "layer",
+                params: stmt.layer.filter(layer => layer !== "").join("."),
+                source: parent.source,
+              });
+
+              innerAtRule = layerNode;
+              outerAtRule = layerNode;
+            }
+
+            parent.insertBefore(nodes[0], outerAtRule);
 
             // remove nodes
             nodes.forEach(node => {
@@ -529,11 +606,11 @@ function AtImport(options) {
             // better output
             nodes[0].raws.before = nodes[0].raws.before || "\n";
 
-            // wrap new rules with media query
-            mediaNode.append(nodes);
+            // wrap new rules with media query and/or layer at rule
+            innerAtRule.append(nodes);
 
             stmt.type = "media";
-            stmt.node = mediaNode;
+            stmt.node = outerAtRule;
             delete stmt.nodes;
           }
         });
@@ -556,7 +633,7 @@ function AtImport(options) {
         });
       }
 
-      function parseStyles(result, styles, options, state, media) {
+      function parseStyles(result, styles, options, state, media, layer) {
         const statements = parseStatements(result, styles);
 
         return Promise.resolve(statements)
@@ -565,6 +642,7 @@ function AtImport(options) {
             return stmts.reduce((promise, stmt) => {
               return promise.then(() => {
                 stmt.media = joinMedia(media, stmt.media || []);
+                stmt.layer = joinLayer(layer, stmt.layer || []);
 
                 // skip protocol base uri (protocol://url) or protocol-relative
                 if (
@@ -676,7 +754,7 @@ function AtImport(options) {
 
       function loadImportContent(result, stmt, filename, options, state) {
         const atRule = stmt.node;
-        const { media } = stmt;
+        const { media, layer } = stmt;
         if (options.skipDuplicates) {
           // skip files already imported at the same scope
           if (
@@ -724,7 +802,7 @@ function AtImport(options) {
               }
 
               // recursion: import @import from imported file
-              return parseStyles(result, styles, options, state, media)
+              return parseStyles(result, styles, options, state, media, layer)
             })
           }
         )

package/dist/node/cli.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var require$$0 = require('events');
-var index = require('./chunks/dep-62435a6f.js');
+var index = require('./chunks/dep-7a52803b.js');
 var perf_hooks = require('perf_hooks');
 require('fs');
 require('path');
@@ -19,9 +19,9 @@ require('zlib');
 require('crypto');
 require('tls');
 require('assert');
+require('esbuild');
 require('buffer');
 require('querystring');
-require('esbuild');
 require('child_process');
 require('worker_threads');
 require('readline');
@@ -683,7 +683,7 @@ cli
     .action(async (root, options) => {
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.index$1; });
+    const { createServer } = await Promise.resolve().then(function () { return require('./chunks/dep-7a52803b.js'); }).then(function (n) { return n.index$1; });
     try {
         const server = await createServer({
             root,
@@ -732,7 +732,7 @@ cli
     .option('--emptyOutDir', `[boolean] force empty outDir when it's outside of root`)
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
-    const { build } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.build$1; });
+    const { build } = await Promise.resolve().then(function () { return require('./chunks/dep-7a52803b.js'); }).then(function (n) { return n.build$1; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -755,7 +755,7 @@ cli
     .command('optimize [root]', 'pre-bundle dependencies')
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
-    const { optimizeDeps } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.index; });
+    const { optimizeDeps } = await Promise.resolve().then(function () { return require('./chunks/dep-7a52803b.js'); }).then(function (n) { return n.index; });
     try {
         const config = await index.resolveConfig({
             root,
@@ -778,7 +778,7 @@ cli
     .option('--https', `[boolean] use TLS + HTTP/2`)
     .option('--open [path]', `[boolean | string] open browser on startup`)
     .action(async (root, options) => {
-    const { preview } = await Promise.resolve().then(function () { return require('./chunks/dep-62435a6f.js'); }).then(function (n) { return n.preview$1; });
+    const { preview } = await Promise.resolve().then(function () { return require('./chunks/dep-7a52803b.js'); }).then(function (n) { return n.preview$1; });
     try {
         const server = await preview({
             root,