@vercel/node 3.2.13 → 3.2.15

package/dist/index.js

@@ -19096,9 +19096,9 @@ var require_set_array_umd = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.15/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
+// ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
 var require_sourcemap_codec_umd = __commonJS({
-  "../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.4.15/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports, module2) {
+  "../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports, module2) {
     (function(global2, factory) {
       typeof exports === "object" && typeof module2 !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.sourcemapCodec = {}));
     })(exports, function(exports2) {
@@ -19113,6 +19113,41 @@ var require_sourcemap_codec_umd = __commonJS({
         intToChar[i] = c;
         charToInt[c] = i;
       }
+      function decodeInteger(reader, relative3) {
+        let value2 = 0;
+        let shift = 0;
+        let integer = 0;
+        do {
+          const c = reader.next();
+          integer = charToInt[c];
+          value2 |= (integer & 31) << shift;
+          shift += 5;
+        } while (integer & 32);
+        const shouldNegate = value2 & 1;
+        value2 >>>= 1;
+        if (shouldNegate) {
+          value2 = -2147483648 | -value2;
+        }
+        return relative3 + value2;
+      }
+      function encodeInteger(builder, num, relative3) {
+        let delta = num - relative3;
+        delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+        do {
+          let clamped = delta & 31;
+          delta >>>= 5;
+          if (delta > 0)
+            clamped |= 32;
+          builder.write(intToChar[clamped]);
+        } while (delta > 0);
+        return num;
+      }
+      function hasMoreVlq(reader, max) {
+        if (reader.pos >= max)
+          return false;
+        return reader.peek() !== comma;
+      }
+      const bufLength = 1024 * 16;
       const td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? {
         decode(buf) {
           const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
@@ -19127,72 +19162,317 @@ var require_sourcemap_codec_umd = __commonJS({
           return out;
         }
       };
+      class StringWriter {
+        constructor() {
+          this.pos = 0;
+          this.out = "";
+          this.buffer = new Uint8Array(bufLength);
+        }
+        write(v) {
+          const { buffer } = this;
+          buffer[this.pos++] = v;
+          if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+          }
+        }
+        flush() {
+          const { buffer, out, pos } = this;
+          return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+        }
+      }
+      class StringReader {
+        constructor(buffer) {
+          this.pos = 0;
+          this.buffer = buffer;
+        }
+        next() {
+          return this.buffer.charCodeAt(this.pos++);
+        }
+        peek() {
+          return this.buffer.charCodeAt(this.pos);
+        }
+        indexOf(char) {
+          const { buffer, pos } = this;
+          const idx = buffer.indexOf(char, pos);
+          return idx === -1 ? buffer.length : idx;
+        }
+      }
+      const EMPTY = [];
+      function decodeOriginalScopes(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const scopes = [];
+        const stack = [];
+        let line = 0;
+        for (; reader.pos < length; reader.pos++) {
+          line = decodeInteger(reader, line);
+          const column = decodeInteger(reader, 0);
+          if (!hasMoreVlq(reader, length)) {
+            const last = stack.pop();
+            last[2] = line;
+            last[3] = column;
+            continue;
+          }
+          const kind = decodeInteger(reader, 0);
+          const fields = decodeInteger(reader, 0);
+          const hasName = fields & 1;
+          const scope = hasName ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind];
+          let vars = EMPTY;
+          if (hasMoreVlq(reader, length)) {
+            vars = [];
+            do {
+              const varsIndex = decodeInteger(reader, 0);
+              vars.push(varsIndex);
+            } while (hasMoreVlq(reader, length));
+          }
+          scope.vars = vars;
+          scopes.push(scope);
+          stack.push(scope);
+        }
+        return scopes;
+      }
+      function encodeOriginalScopes(scopes) {
+        const writer = new StringWriter();
+        for (let i = 0; i < scopes.length; ) {
+          i = _encodeOriginalScopes(scopes, i, writer, [0]);
+        }
+        return writer.flush();
+      }
+      function _encodeOriginalScopes(scopes, index, writer, state) {
+        const scope = scopes[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+        if (index > 0)
+          writer.write(comma);
+        state[0] = encodeInteger(writer, startLine, state[0]);
+        encodeInteger(writer, startColumn, 0);
+        encodeInteger(writer, kind, 0);
+        const fields = scope.length === 6 ? 1 : 0;
+        encodeInteger(writer, fields, 0);
+        if (scope.length === 6)
+          encodeInteger(writer, scope[5], 0);
+        for (const v of vars) {
+          encodeInteger(writer, v, 0);
+        }
+        for (index++; index < scopes.length; ) {
+          const next = scopes[index];
+          const { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn) {
+            break;
+          }
+          index = _encodeOriginalScopes(scopes, index, writer, state);
+        }
+        writer.write(comma);
+        state[0] = encodeInteger(writer, endLine, state[0]);
+        encodeInteger(writer, endColumn, 0);
+        return index;
+      }
+      function decodeGeneratedRanges(input) {
+        const { length } = input;
+        const reader = new StringReader(input);
+        const ranges = [];
+        const stack = [];
+        let genLine = 0;
+        let definitionSourcesIndex = 0;
+        let definitionScopeIndex = 0;
+        let callsiteSourcesIndex = 0;
+        let callsiteLine = 0;
+        let callsiteColumn = 0;
+        let bindingLine = 0;
+        let bindingColumn = 0;
+        do {
+          const semi = reader.indexOf(";");
+          let genColumn = 0;
+          for (; reader.pos < semi; reader.pos++) {
+            genColumn = decodeInteger(reader, genColumn);
+            if (!hasMoreVlq(reader, semi)) {
+              const last = stack.pop();
+              last[2] = genLine;
+              last[3] = genColumn;
+              continue;
+            }
+            const fields = decodeInteger(reader, 0);
+            const hasDefinition = fields & 1;
+            const hasCallsite = fields & 2;
+            const hasScope = fields & 4;
+            let callsite = null;
+            let bindings = EMPTY;
+            let range;
+            if (hasDefinition) {
+              const defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+              definitionScopeIndex = decodeInteger(reader, definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0);
+              definitionSourcesIndex = defSourcesIndex;
+              range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+            } else {
+              range = [genLine, genColumn, 0, 0];
+            }
+            range.isScope = !!hasScope;
+            if (hasCallsite) {
+              const prevCsi = callsiteSourcesIndex;
+              const prevLine = callsiteLine;
+              callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+              const sameSource = prevCsi === callsiteSourcesIndex;
+              callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0);
+              callsiteColumn = decodeInteger(reader, sameSource && prevLine === callsiteLine ? callsiteColumn : 0);
+              callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+            }
+            range.callsite = callsite;
+            if (hasMoreVlq(reader, semi)) {
+              bindings = [];
+              do {
+                bindingLine = genLine;
+                bindingColumn = genColumn;
+                const expressionsCount = decodeInteger(reader, 0);
+                let expressionRanges;
+                if (expressionsCount < -1) {
+                  expressionRanges = [[decodeInteger(reader, 0)]];
+                  for (let i = -1; i > expressionsCount; i--) {
+                    const prevBl = bindingLine;
+                    bindingLine = decodeInteger(reader, bindingLine);
+                    bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+                    const expression = decodeInteger(reader, 0);
+                    expressionRanges.push([expression, bindingLine, bindingColumn]);
+                  }
+                } else {
+                  expressionRanges = [[expressionsCount]];
+                }
+                bindings.push(expressionRanges);
+              } while (hasMoreVlq(reader, semi));
+            }
+            range.bindings = bindings;
+            ranges.push(range);
+            stack.push(range);
+          }
+          genLine++;
+          reader.pos = semi + 1;
+        } while (reader.pos < length);
+        return ranges;
+      }
+      function encodeGeneratedRanges(ranges) {
+        if (ranges.length === 0)
+          return "";
+        const writer = new StringWriter();
+        for (let i = 0; i < ranges.length; ) {
+          i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+        }
+        return writer.flush();
+      }
+      function _encodeGeneratedRanges(ranges, index, writer, state) {
+        const range = ranges[index];
+        const { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, isScope, callsite, bindings } = range;
+        if (state[0] < startLine) {
+          catchupLine(writer, state[0], startLine);
+          state[0] = startLine;
+          state[1] = 0;
+        } else if (index > 0) {
+          writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, range[1], state[1]);
+        const fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
+        encodeInteger(writer, fields, 0);
+        if (range.length === 6) {
+          const { 4: sourcesIndex, 5: scopesIndex } = range;
+          if (sourcesIndex !== state[2]) {
+            state[3] = 0;
+          }
+          state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+          state[3] = encodeInteger(writer, scopesIndex, state[3]);
+        }
+        if (callsite) {
+          const { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+          if (sourcesIndex !== state[4]) {
+            state[5] = 0;
+            state[6] = 0;
+          } else if (callLine !== state[5]) {
+            state[6] = 0;
+          }
+          state[4] = encodeInteger(writer, sourcesIndex, state[4]);
+          state[5] = encodeInteger(writer, callLine, state[5]);
+          state[6] = encodeInteger(writer, callColumn, state[6]);
+        }
+        if (bindings) {
+          for (const binding of bindings) {
+            if (binding.length > 1)
+              encodeInteger(writer, -binding.length, 0);
+            const expression = binding[0][0];
+            encodeInteger(writer, expression, 0);
+            let bindingStartLine = startLine;
+            let bindingStartColumn = startColumn;
+            for (let i = 1; i < binding.length; i++) {
+              const expRange = binding[i];
+              bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine);
+              bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn);
+              encodeInteger(writer, expRange[0], 0);
+            }
+          }
+        }
+        for (index++; index < ranges.length; ) {
+          const next = ranges[index];
+          const { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn) {
+            break;
+          }
+          index = _encodeGeneratedRanges(ranges, index, writer, state);
+        }
+        if (state[0] < endLine) {
+          catchupLine(writer, state[0], endLine);
+          state[0] = endLine;
+          state[1] = 0;
+        } else {
+          writer.write(comma);
+        }
+        state[1] = encodeInteger(writer, endColumn, state[1]);
+        return index;
+      }
+      function catchupLine(writer, lastLine, line) {
+        do {
+          writer.write(semicolon);
+        } while (++lastLine < line);
+      }
       function decode(mappings) {
-        const state = new Int32Array(5);
+        const { length } = mappings;
+        const reader = new StringReader(mappings);
         const decoded = [];
-        let index = 0;
+        let genColumn = 0;
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
         do {
-          const semi = indexOf(mappings, index);
+          const semi = reader.indexOf(";");
           const line = [];
           let sorted = true;
           let lastCol = 0;
-          state[0] = 0;
-          for (let i = index; i < semi; i++) {
+          genColumn = 0;
+          while (reader.pos < semi) {
             let seg;
-            i = decodeInteger(mappings, i, state, 0);
-            const col = state[0];
-            if (col < lastCol)
+            genColumn = decodeInteger(reader, genColumn);
+            if (genColumn < lastCol)
               sorted = false;
-            lastCol = col;
-            if (hasMoreVlq(mappings, i, semi)) {
-              i = decodeInteger(mappings, i, state, 1);
-              i = decodeInteger(mappings, i, state, 2);
-              i = decodeInteger(mappings, i, state, 3);
-              if (hasMoreVlq(mappings, i, semi)) {
-                i = decodeInteger(mappings, i, state, 4);
-                seg = [col, state[1], state[2], state[3], state[4]];
+            lastCol = genColumn;
+            if (hasMoreVlq(reader, semi)) {
+              sourcesIndex = decodeInteger(reader, sourcesIndex);
+              sourceLine = decodeInteger(reader, sourceLine);
+              sourceColumn = decodeInteger(reader, sourceColumn);
+              if (hasMoreVlq(reader, semi)) {
+                namesIndex = decodeInteger(reader, namesIndex);
+                seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
               } else {
-                seg = [col, state[1], state[2], state[3]];
+                seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
               }
             } else {
-              seg = [col];
+              seg = [genColumn];
             }
             line.push(seg);
+            reader.pos++;
           }
           if (!sorted)
             sort(line);
           decoded.push(line);
-          index = semi + 1;
-        } while (index <= mappings.length);
+          reader.pos = semi + 1;
+        } while (reader.pos <= length);
         return decoded;
       }
-      function indexOf(mappings, index) {
-        const idx = mappings.indexOf(";", index);
-        return idx === -1 ? mappings.length : idx;
-      }
-      function decodeInteger(mappings, pos, state, j) {
-        let value2 = 0;
-        let shift = 0;
-        let integer = 0;
-        do {
-          const c = mappings.charCodeAt(pos++);
-          integer = charToInt[c];
-          value2 |= (integer & 31) << shift;
-          shift += 5;
-        } while (integer & 32);
-        const shouldNegate = value2 & 1;
-        value2 >>>= 1;
-        if (shouldNegate) {
-          value2 = -2147483648 | -value2;
-        }
-        state[j] += value2;
-        return pos;
-      }
-      function hasMoreVlq(mappings, i, length) {
-        if (i >= length)
-          return false;
-        return mappings.charCodeAt(i) !== comma;
-      }
       function sort(line) {
         line.sort(sortComparator);
       }
@@ -19200,63 +19480,41 @@ var require_sourcemap_codec_umd = __commonJS({
         return a[0] - b[0];
       }
       function encode(decoded) {
-        const state = new Int32Array(5);
-        const bufLength = 1024 * 16;
-        const subLength = bufLength - 36;
-        const buf = new Uint8Array(bufLength);
-        const sub = buf.subarray(0, subLength);
-        let pos = 0;
-        let out = "";
+        const writer = new StringWriter();
+        let sourcesIndex = 0;
+        let sourceLine = 0;
+        let sourceColumn = 0;
+        let namesIndex = 0;
         for (let i = 0; i < decoded.length; i++) {
           const line = decoded[i];
-          if (i > 0) {
-            if (pos === bufLength) {
-              out += td.decode(buf);
-              pos = 0;
-            }
-            buf[pos++] = semicolon;
-          }
+          if (i > 0)
+            writer.write(semicolon);
           if (line.length === 0)
             continue;
-          state[0] = 0;
+          let genColumn = 0;
           for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            if (pos > subLength) {
-              out += td.decode(sub);
-              buf.copyWithin(0, subLength, pos);
-              pos -= subLength;
-            }
             if (j > 0)
-              buf[pos++] = comma;
-            pos = encodeInteger(buf, pos, state, segment, 0);
+              writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
               continue;
-            pos = encodeInteger(buf, pos, state, segment, 1);
-            pos = encodeInteger(buf, pos, state, segment, 2);
-            pos = encodeInteger(buf, pos, state, segment, 3);
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
               continue;
-            pos = encodeInteger(buf, pos, state, segment, 4);
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
           }
         }
-        return out + td.decode(buf.subarray(0, pos));
-      }
-      function encodeInteger(buf, pos, state, segment, j) {
-        const next = segment[j];
-        let num = next - state[j];
-        state[j] = next;
-        num = num < 0 ? -num << 1 | 1 : num << 1;
-        do {
-          let clamped = num & 31;
-          num >>>= 5;
-          if (num > 0)
-            clamped |= 32;
-          buf[pos++] = intToChar[clamped];
-        } while (num > 0);
-        return pos;
+        return writer.flush();
       }
       exports2.decode = decode;
+      exports2.decodeGeneratedRanges = decodeGeneratedRanges;
+      exports2.decodeOriginalScopes = decodeOriginalScopes;
       exports2.encode = encode;
+      exports2.encodeGeneratedRanges = encodeGeneratedRanges;
+      exports2.encodeOriginalScopes = encodeOriginalScopes;
       Object.defineProperty(exports2, "__esModule", { value: true });
     });
   }
@@ -26079,9 +26337,9 @@ var require_js_tokens = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/picocolors@1.0.1/node_modules/picocolors/picocolors.js
+// ../../node_modules/.pnpm/picocolors@1.1.0/node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
-  "../../node_modules/.pnpm/picocolors@1.0.1/node_modules/picocolors/picocolors.js"(exports, module2) {
+  "../../node_modules/.pnpm/picocolors@1.1.0/node_modules/picocolors/picocolors.js"(exports, module2) {
     var argv = process.argv || [];
     var env = process.env;
     var isColorSupported = !("NO_COLOR" in env || argv.includes("--no-color")) && ("FORCE_COLOR" in env || argv.includes("--color") || process.platform === "win32" || require != null && require("tty").isatty(1) && env.TERM !== "dumb" || "CI" in env);
@@ -26128,7 +26386,23 @@ var require_picocolors = __commonJS({
         bgBlue: init("\x1B[44m", "\x1B[49m"),
         bgMagenta: init("\x1B[45m", "\x1B[49m"),
         bgCyan: init("\x1B[46m", "\x1B[49m"),
-        bgWhite: init("\x1B[47m", "\x1B[49m")
+        bgWhite: init("\x1B[47m", "\x1B[49m"),
+        blackBright: init("\x1B[90m", "\x1B[39m"),
+        redBright: init("\x1B[91m", "\x1B[39m"),
+        greenBright: init("\x1B[92m", "\x1B[39m"),
+        yellowBright: init("\x1B[93m", "\x1B[39m"),
+        blueBright: init("\x1B[94m", "\x1B[39m"),
+        magentaBright: init("\x1B[95m", "\x1B[39m"),
+        cyanBright: init("\x1B[96m", "\x1B[39m"),
+        whiteBright: init("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: init("\x1B[100m", "\x1B[49m"),
+        bgRedBright: init("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: init("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: init("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: init("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: init("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: init("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: init("\x1B[107m", "\x1B[49m")
       };
     };
     module2.exports = createColors();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "3.2.13",
+  "version": "3.2.15",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -17,7 +17,7 @@
     "@edge-runtime/primitives": "4.1.0",
     "@edge-runtime/vm": "3.2.0",
     "@types/node": "16.18.11",
-    "@vercel/build-utils": "8.4.1",
+    "@vercel/build-utils": "8.4.3",
     "@vercel/error-utils": "2.0.2",
     "@vercel/nft": "0.27.3",
     "@vercel/static-config": "3.0.0",