@danielx/civet 0.7.10 → 0.7.11

package/dist/main.mjs

@@ -940,27 +940,49 @@ function assignResults(node, collect) {
     case "DebuggerStatement":
     case "EmptyStatement":
     case "ReturnStatement":
-    case "ThrowStatement":
+    case "ThrowStatement": {
       return;
-    case "Declaration":
+    }
+    case "Declaration": {
+      let ref5;
+      if (exp.bindings?.length) {
+        ref5 = patternAsValue((ref4 = exp.bindings)[ref4.length - 1].pattern);
+      } else {
+        ref5 = "void 0";
+      }
+      ;
+      const value = ref5;
       exp.children.push([
         "",
-        [";", collect(patternAsValue((ref4 = exp.bindings)[ref4.length - 1].pattern))]
+        [";", collect(value)]
       ]);
       return;
+    }
+    case "FunctionExpression": {
+      if (exp.id) {
+        exp.children.push([
+          "",
+          [";", collect(exp.id)]
+        ]);
+        return;
+      }
+      break;
+    }
     case "ForStatement":
     case "IterationStatement":
     case "DoStatement":
-    case "ComptimeStatement":
+    case "ComptimeStatement": {
       wrapIterationReturningResults(exp, outer, collect);
       return;
-    case "BlockStatement":
+    }
+    case "BlockStatement": {
       if (node.expressions.some(isExit)) {
         return;
       }
       assignResults(exp.expressions[exp.expressions.length - 1], collect);
       return;
-    case "IfStatement":
+    }
+    case "IfStatement": {
       assignResults(exp.then, collect);
       if (exp.then.bare && !exp.then.semicolon) {
         exp.then.children.push(exp.then.semicolon = ";");
@@ -968,18 +990,22 @@ function assignResults(node, collect) {
       if (exp.else) {
         assignResults(exp.else.block, collect);
       } else {
-        exp.children.push([" else {", collect("undefined"), "}"]);
+        exp.children.push([" else {", collect("void 0"), "}"]);
       }
       return;
-    case "PatternMatchingStatement":
+    }
+    case "PatternMatchingStatement": {
       assignResults(exp.children[0], collect);
       return;
-    case "SwitchStatement":
+    }
+    case "SwitchStatement": {
       assignResults(exp.children[2], collect);
       return;
-    case "TryStatement":
+    }
+    case "TryStatement": {
       exp.blocks.forEach((block) => assignResults(block, collect));
       return;
+    }
   }
   if (node[node.length - 1]?.type === "SemicolonDelimiter") {
     return;
@@ -990,7 +1016,7 @@ function insertReturn(node, outerNode = node) {
   if (!node)
     return;
   switch (node.type) {
-    case "BlockStatement":
+    case "BlockStatement": {
       if (node.expressions.length) {
         if (node.expressions.some(([, exp2]) => isExit(exp2))) {
           return;
@@ -1003,7 +1029,8 @@ function insertReturn(node, outerNode = node) {
         }
       }
       return;
-    case "WhenClause":
+    }
+    case "WhenClause": {
       if (node.break) {
         node.children.splice(node.children.indexOf(node.break), 1);
       }
@@ -1013,9 +1040,11 @@ function insertReturn(node, outerNode = node) {
         node.block.expressions.push(wrapWithReturn());
       }
       return;
-    case "DefaultClause":
+    }
+    case "DefaultClause": {
       insertReturn(node.block);
       return;
+    }
   }
   if (!Array.isArray(node))
     return;
@@ -1035,23 +1064,36 @@ function insertReturn(node, outerNode = node) {
     exp = exp.statement;
     ({ type } = exp);
   }
-  let ref5;
+  let ref6;
   switch (type) {
     case "BreakStatement":
     case "ContinueStatement":
     case "DebuggerStatement":
     case "EmptyStatement":
     case "ReturnStatement":
-    case "ThrowStatement":
+    case "ThrowStatement": {
       return;
-    case "Declaration":
+    }
+    case "Declaration": {
+      let ref7;
+      if (exp.bindings?.length) {
+        ref7 = [" ", patternAsValue((ref6 = exp.bindings)[ref6.length - 1].pattern)];
+      } else {
+        ref7 = [];
+      }
+      ;
+      const value = ref7;
       exp.children.push(["", {
         type: "ReturnStatement",
-        children: [";return ", patternAsValue((ref5 = exp.bindings)[ref5.length - 1].pattern)],
+        children: [
+          ";return",
+          ...value
+        ],
         parent: exp
       }]);
       return;
-    case "FunctionExpression":
+    }
+    case "FunctionExpression": {
       if (exp.id) {
         exp.children.push([
           "",
@@ -1064,16 +1106,19 @@ function insertReturn(node, outerNode = node) {
         return;
       }
       break;
+    }
     case "ForStatement":
     case "IterationStatement":
     case "DoStatement":
-    case "ComptimeStatement":
+    case "ComptimeStatement": {
       wrapIterationReturningResults(exp, outer);
       return;
-    case "BlockStatement":
+    }
+    case "BlockStatement": {
       insertReturn(exp.expressions[exp.expressions.length - 1]);
       return;
-    case "IfStatement":
+    }
+    case "IfStatement": {
       insertReturn(exp.then);
       if (exp.else)
         insertReturn(exp.else.block);
@@ -1085,18 +1130,23 @@ function insertReturn(node, outerNode = node) {
           parent: exp
         }]);
       return;
-    case "PatternMatchingStatement":
+    }
+    case "PatternMatchingStatement": {
       insertReturn(exp.children[0]);
       return;
-    case "SwitchStatement":
+    }
+    case "SwitchStatement": {
       insertSwitchReturns(exp);
       return;
-    case "TryStatement":
+    }
+    case "TryStatement": {
       exp.blocks.forEach((block) => insertReturn(block));
       return;
+    }
   }
-  if (node[node.length - 1]?.type === "SemicolonDelimiter")
+  if (node[node.length - 1]?.type === "SemicolonDelimiter") {
     return;
+  }
   const returnStatement = wrapWithReturn(node[1]);
   node.splice(1, 1, returnStatement);
 }
@@ -1185,10 +1235,33 @@ function processParams(f) {
   }
   expressions.unshift(...prefix);
 }
+function processSignature(f) {
+  const { block, signature } = f;
+  if (hasAwait(block) && !f.async?.length) {
+    f.async.push("async ");
+    signature.modifier.async = true;
+  }
+  if (hasYield(block) && !f.generator?.length) {
+    if (f.type === "ArrowFunction") {
+      gatherRecursiveWithinFunction(block, ($) => $.type === "YieldExpression").forEach((y) => {
+        const i = y.children.findIndex(($1) => $1.type === "Yield");
+        return y.children.splice(i + 1, 0, {
+          type: "Error",
+          message: "Can't use yield inside of => arrow function"
+        });
+      });
+    } else {
+      f.generator.push("*");
+      signature.modifier.generator = true;
+    }
+  }
+}
 function processFunctions(statements, config2) {
   gatherRecursiveAll(statements, ({ type }) => type === "FunctionExpression" || type === "ArrowFunction").forEach((f) => {
-    if (f.type === "FunctionExpression")
+    if (f.type === "FunctionExpression") {
       implicitFunctionBlock(f);
+    }
+    processSignature(f);
     processParams(f);
     return processReturn(f, config2.implicitReturns);
   });
@@ -1245,12 +1318,12 @@ function processCoffeeDo(ws, expression) {
       ...parameters,
       children: (() => {
         const results = [];
-        for (let ref6 = parameters.children, i1 = 0, len3 = ref6.length; i1 < len3; i1++) {
-          let parameter = ref6[i1];
+        for (let ref8 = parameters.children, i1 = 0, len3 = ref8.length; i1 < len3; i1++) {
+          let parameter = ref8[i1];
           if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-            let ref7;
-            if (ref7 = parameter.initializer) {
-              const initializer = ref7;
+            let ref9;
+            if (ref9 = parameter.initializer) {
+              const initializer = ref9;
               args.push(initializer.expression, parameter.delim);
               parameter = {
                 ...parameter,
@@ -1271,7 +1344,7 @@ function processCoffeeDo(ws, expression) {
     expression = {
       ...expression,
       parameters: newParameters,
-      children: expression.children.map(($) => $ === parameters ? newParameters : $)
+      children: expression.children.map(($2) => $2 === parameters ? newParameters : $2)
     };
   }
   return {
@@ -1286,6 +1359,52 @@ function processCoffeeDo(ws, expression) {
     ]
   };
 }
+function makeAmpersandFunction(rhs) {
+  let { ref, typeSuffix, body } = rhs;
+  if (!(ref != null)) {
+    ref = makeRef("$");
+    inplacePrepend(ref, body);
+  }
+  if (body?.type === "ObjectExpression") {
+    body = makeLeftHandSideExpression(body);
+  }
+  const parameters = makeNode({
+    type: "Parameters",
+    children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
+    names: []
+  });
+  const expressions = [[" ", body]];
+  const block = makeNode({
+    type: "BlockStatement",
+    bare: true,
+    expressions,
+    children: [expressions],
+    implicitlyReturned: true
+  });
+  const async = [];
+  const children = [async, parameters, " =>", block];
+  const fn = makeNode({
+    type: "ArrowFunction",
+    async,
+    signature: {
+      modifier: {
+        async: !!async
+      }
+    },
+    children,
+    ref,
+    block,
+    parameters,
+    ampersandBlock: true,
+    body
+  });
+  if (isStatement(body)) {
+    braceBlock(block);
+    fn.ampersandBlock = false;
+    delete fn.body;
+  }
+  return fn;
+}
 
 // source/parser/block.civet
 function blockWithPrefix(prefixStatements, block) {
@@ -1509,8 +1628,8 @@ function addParentPointers(node, parent) {
     node.parent = parent;
   }
   if (node.children) {
-    for (let ref1 = node.children, i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
-      const child = ref1[i1];
+    for (let ref = node.children, i1 = 0, len1 = ref.length; i1 < len1; i1++) {
+      const child = ref[i1];
       addParentPointers(child, node);
     }
   }
@@ -1792,13 +1911,13 @@ function startsWith(target, value) {
   return;
 }
 function hasAwait(exp) {
-  return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
+  return gatherRecursiveWithinFunction(exp, ($1) => $1.type === "Await").length > 0;
 }
 function hasYield(exp) {
-  return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
+  return gatherRecursiveWithinFunction(exp, ($2) => $2.type === "Yield").length > 0;
 }
 function hasImportDeclaration(exp) {
-  return gatherRecursiveWithinFunction(exp, ({ type }) => type === "ImportDeclaration").length > 0;
+  return gatherRecursiveWithinFunction(exp, ($3) => $3.type === "ImportDeclaration").length > 0;
 }
 function deepCopy(node) {
   if (node == null)
@@ -1836,54 +1955,6 @@ function removeHoistDecs(node) {
     }
   }
 }
-function makeAmpersandFunction(rhs) {
-  let { ref, typeSuffix, body } = rhs;
-  if (!(ref != null)) {
-    ref = makeRef("$");
-    inplacePrepend(ref, body);
-  }
-  if (body?.type === "ObjectExpression") {
-    body = makeLeftHandSideExpression(body);
-  }
-  const parameters = makeNode({
-    type: "Parameters",
-    children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
-    names: []
-  });
-  const expressions = [[" ", body]];
-  const block = makeNode({
-    type: "BlockStatement",
-    bare: true,
-    expressions,
-    children: [expressions],
-    implicitlyReturned: true
-  });
-  const children = [parameters, " =>", block];
-  const async = hasAwait(body);
-  if (async) {
-    children.unshift("async ");
-  }
-  const fn = makeNode({
-    type: "ArrowFunction",
-    signature: {
-      modifier: {
-        async
-      }
-    },
-    children,
-    ref,
-    block,
-    parameters,
-    ampersandBlock: true,
-    body
-  });
-  if (isStatement(body)) {
-    braceBlock(block);
-    fn.ampersandBlock = false;
-    delete fn.body;
-  }
-  return fn;
-}
 var skipParens = /* @__PURE__ */ new Set([
   "AmpersandRef",
   "CallExpression",
@@ -1934,8 +2005,8 @@ function updateParentPointers(node, parent, depth = 1) {
     node.parent = parent;
   }
   if (depth && isParent(node)) {
-    for (let ref2 = node.children, i3 = 0, len3 = ref2.length; i3 < len3; i3++) {
-      const child = ref2[i3];
+    for (let ref1 = node.children, i3 = 0, len3 = ref1.length; i3 < len3; i3++) {
+      const child = ref1[i3];
       updateParentPointers(child, node, depth - 1);
     }
   }
@@ -2006,11 +2077,11 @@ function parenthesizeType(type) {
 }
 function wrapIIFE(expressions, asyncFlag) {
   let prefix;
-  let async;
+  const async = [];
   if (asyncFlag) {
-    async = "async ";
+    async.push("async ");
   } else if (hasAwait(expressions)) {
-    async = "async ";
+    async.push("async ");
     prefix = {
       type: "Await",
       children: ["await "]
@@ -2021,8 +2092,7 @@ function wrapIIFE(expressions, asyncFlag) {
     expressions,
     children: ["{", expressions, "}"],
     bare: false,
-    root: false,
-    parent: void 0
+    root: false
   });
   const parameters = {
     type: "Parameters",
@@ -2031,7 +2101,7 @@ function wrapIIFE(expressions, asyncFlag) {
   };
   const signature = {
     modifier: {
-      async: !!async
+      async: !!async.length
     },
     returnType: void 0
   };
@@ -2374,8 +2444,6 @@ function processBinaryOpExpression($0) {
     }
     return expandedOps;
   }
-  ;
-  return recurse;
 }
 function dotNumericLiteral(literal) {
   if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
@@ -2892,7 +2960,13 @@ function getPatternBlockPrefix(pattern, ref, decl = "const ", suffix) {
   thisAssignments = thisAssignments.map(($6) => ["", $6, ";"]);
   const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices]);
   return [
-    ["", [decl, patternBindings, suffix, " = ", ref, ...splices], ";"],
+    ["", {
+      type: "Declaration",
+      children: [decl, patternBindings, suffix, " = ", ref, ...splices],
+      names: [],
+      bindings: []
+      // avoid implicit return of any bindings
+    }, ";"],
     ...thisAssignments,
     ...duplicateDeclarations.map(($7) => ["", $7, ";"])
   ];
@@ -3040,9 +3114,18 @@ function aggregateDuplicateBindings(bindings) {
       aliasBinding(p, ref);
       return ref;
     });
-    return declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
-      return i === 0 ? r : [", ", r];
-    }), "]"]);
+    return declarations.push({
+      type: "Declaration",
+      children: [
+        "const ",
+        key,
+        " = [",
+        ...refs.map((r, i) => i === 0 ? r : [", ", r]),
+        "]"
+      ],
+      names: [],
+      bindings: []
+    });
   });
   return declarations;
 }
@@ -3533,8 +3616,7 @@ function processUnaryExpression(pre, exp, post) {
       token: " != null"
     };
     if (pre.length) {
-      let ref;
-      const lastPre = (ref = pre)[ref.length - 1];
+      const lastPre = pre[pre.length - 1];
       if (lastPre.token === "!") {
         post.token = " == null";
         pre = pre.slice(0, -1);
@@ -3578,9 +3660,9 @@ function processUnaryExpression(pre, exp, post) {
       }
     }
   }
-  let ref1;
-  while (ref1 = pre.length) {
-    const l = ref1;
+  let ref;
+  while (ref = pre.length) {
+    const l = ref;
     const last = pre[l - 1];
     if (last.type === "Await") {
       if (last.op) {
@@ -4234,8 +4316,6 @@ function gen(root, options) {
     debugger;
     throw new Error(`Unknown node ${stringify(node)}`);
   }
-  ;
-  return recurse;
 }
 var generate_default = gen;
 function prune(node) {
@@ -4811,8 +4891,11 @@ function expressionizeBlock(blockOrExpression) {
     }
     if (results.length > 1) {
       return makeLeftHandSideExpression(results);
+    } else if (results.length) {
+      return results;
+    } else {
+      return ["void 0"];
     }
-    return results;
   } else {
     return blockOrExpression;
   }
@@ -4839,10 +4922,10 @@ function expressionizeIfStatement(statement) {
     children.push(":void 0");
   }
   children.push(closeParen);
-  return {
+  return makeNode({
     type: "IfExpression",
     children
-  };
+  });
 }
 function expressionizeTypeIf([ws, ifOp, condition, t, e]) {
   const children = [
@@ -7864,16 +7947,8 @@ var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$
   var suffix = $3;
   var arrow = $4;
   var expOrBlock = $5;
-  if (hasAwait(expOrBlock) && !async) {
-    async = "async ";
-  }
-  let error;
-  if (hasYield(expOrBlock)) {
-    error = {
-      type: "Error",
-      message: "Can't use yield inside of => arrow function"
-    };
-  }
+  if (!async)
+    async = [];
   return {
     type: "ArrowFunction",
     signature: {
@@ -7884,10 +7959,9 @@ var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$
     },
     parameters,
     returnType: suffix,
-    ts: false,
     async,
     block: expOrBlock,
-    children: [async, parameters, suffix, arrow, error, expOrBlock]
+    children: [async, parameters, suffix, arrow, expOrBlock]
   };
 });
 var ArrowFunction$$ = [ArrowFunction$0, ArrowFunction$1];
@@ -9524,7 +9598,6 @@ var FunctionSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
     name: id?.name,
     parameters,
     returnType: suffix,
-    ts: false,
     async,
     generator,
     modifier: {
@@ -9550,14 +9623,6 @@ var FunctionExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(FunctionSign
       ts: true
     };
   }
-  if (hasAwait(block) && !signature.async.length) {
-    signature.async.push("async ");
-    signature.modifier.async = true;
-  }
-  if (hasYield(block) && !signature.generator.length) {
-    signature.generator.push("*");
-    signature.modifier.generator = true;
-  }
   return {
     ...signature,
     type: "FunctionExpression",
@@ -9729,15 +9794,21 @@ var OperatorDeclaration$$ = [OperatorDeclaration$0, OperatorDeclaration$1, Opera
 function OperatorDeclaration(ctx, state2) {
   return (0, import_lib3.$EVENT_C)(ctx, state2, "OperatorDeclaration", OperatorDeclaration$$);
 }
-var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Operator, (0, import_lib3.$E)((0, import_lib3.$S)(_, Function2)), _, Identifier, (0, import_lib3.$E)(OperatorBehavior), (0, import_lib3.$E)(_), NonEmptyParameters, (0, import_lib3.$E)(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  var op = $1;
-  var func = $2;
-  var w1 = $3;
-  var id = $4;
-  var behavior = $5;
-  var w2 = $6;
-  var parameters = $7;
-  var suffix = $8;
+var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)((0, import_lib3.$S)(Async, _)), Operator, (0, import_lib3.$E)((0, import_lib3.$S)(_, Function2)), (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star)), _, Identifier, (0, import_lib3.$E)(OperatorBehavior), (0, import_lib3.$E)(_), NonEmptyParameters, (0, import_lib3.$E)(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
+  var async = $1;
+  var op = $2;
+  var func = $3;
+  var generator = $4;
+  var w1 = $5;
+  var id = $6;
+  var behavior = $7;
+  var w2 = $8;
+  var parameters = $9;
+  var suffix = $10;
+  if (!async)
+    async = [];
+  if (!generator)
+    generator = [];
   if (!func) {
     func = { $loc: op.$loc, token: "function" };
   } else {
@@ -9746,12 +9817,17 @@ var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Operator, (0,
   return {
     type: "FunctionSignature",
     id,
-    modifier: {},
+    name: id.name,
     parameters,
     returnType: suffix,
-    ts: false,
+    async,
+    generator,
+    modifier: {
+      async: !!async.length,
+      generator: !!generator.length
+    },
     block: null,
-    children: [func, w1, id, w2, parameters, suffix],
+    children: [async, func, generator, w1, id, w2, parameters, suffix],
     behavior
   };
 });
@@ -9801,27 +9877,24 @@ var ThinArrowFunction$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
   var suffix = $3;
   var arrow = $5;
   var block = $6;
-  if (hasAwait(block) && !async) {
-    async = "async ";
-  }
-  let generator;
-  if (hasYield(block)) {
-    generator = "*";
-  }
+  if (!async)
+    async = [];
+  const generator = [];
   return {
     type: "FunctionExpression",
     id: void 0,
     parameters,
     returnType: suffix,
-    ts: false,
     async,
     generator,
     block,
     signature: {
       name: void 0,
+      async,
+      generator,
       modifier: {
-        async: !!async,
-        generator: !!generator
+        async: !!async.length,
+        generator: !!generator.length
       },
       returnType: suffix
     },
@@ -16578,8 +16651,9 @@ var locationTable = function(input) {
   const lines = [];
   let line = 0;
   let pos = 0;
-  let result;
-  while (result = linesRe.exec(input)) {
+  let ref;
+  while (ref = linesRe.exec(input)) {
+    const result = ref;
     pos += result[0].length;
     lines[line++] = pos;
     if (pos === input.length) {
@@ -16601,7 +16675,8 @@ var SourceMap = function(sourceString) {
   const sm = {
     lines: [[]],
     line: 0,
-    column: 0,
+    colOffset: 0,
+    // relative to previous entry
     srcLine: 0,
     srcColumn: 0,
     srcOffset: 0,
@@ -16610,11 +16685,14 @@ var SourceMap = function(sourceString) {
   const EOL2 = /\r?\n|\r/;
   return {
     data: sm,
+    source: function() {
+      return sourceString;
+    },
     renderMappings: function() {
       let lastSourceLine = 0;
       let lastSourceColumn = 0;
-      return sm.lines.map(function(line) {
-        return line.map(function(entry) {
+      return sm.lines.map((line) => {
+        return line.map((entry) => {
           if (entry.length === 4) {
             let [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
             const lineDelta = srcLine - lastSourceLine;
@@ -16651,25 +16729,25 @@ var SourceMap = function(sourceString) {
         sm.srcColumn = srcCol;
         sm.srcOffset = inputPos + outputStr.length;
       }
-      outLines.forEach(function(line, i) {
+      for (let i1 = 0, len3 = outLines.length; i1 < len3; i1++) {
+        const i = i1;
+        const line = outLines[i1];
         if (i > 0) {
           sm.line++;
           sm.srcLine++;
-          sm.column = 0;
+          sm.colOffset = 0;
           sm.lines[sm.line] = [];
           sm.srcColumn = srcCol = colOffset;
         }
-        const l = sm.column;
-        sm.column += line.length;
+        const l = sm.colOffset;
+        sm.colOffset = line.length;
         sm.srcColumn += line.length;
         if (inputPos != null) {
-          return sm.lines[sm.line].push([l, 0, srcLine + i, srcCol]);
+          sm.lines[sm.line].push([l, 0, srcLine + i, srcCol]);
         } else if (l != 0) {
-          return sm.lines[sm.line].push([l]);
+          sm.lines[sm.line].push([l]);
         }
-        ;
-        return;
-      });
+      }
       return;
     }
   };
@@ -16693,8 +16771,8 @@ var remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
   return remappedCodeWithSourceMap;
 };
 var composeLines = function(upstreamMapping, lines) {
-  return lines.map(function(line) {
-    return line.map(function(entry) {
+  return lines.map((line) => {
+    return line.map((entry) => {
       if (entry.length === 1) {
         return entry;
       }
@@ -16715,11 +16793,11 @@ var parseWithLines = function(base64encodedJSONstr) {
   const json = JSON.parse(Buffer.from(base64encodedJSONstr, "base64").toString("utf8"));
   let sourceLine = 0;
   let sourceColumn = 0;
-  const lines = json.mappings.split(";").map(function(line) {
+  const lines = json.mappings.split(";").map((line) => {
     if (line.length === 0) {
       return [];
     }
-    return line.split(",").map(function(entry) {
+    return line.split(",").map((entry) => {
       const result = decodeVLQ(entry);
       switch (result.length) {
         case 1: {
@@ -16746,12 +16824,12 @@ var VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
 var VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
 var encodeVlq = function(value) {
   let answer = "";
-  let ref;
+  let ref1;
   if (value < 0)
-    ref = 1;
+    ref1 = 1;
   else
-    ref = 0;
-  const signBit = ref;
+    ref1 = 0;
+  const signBit = ref1;
   let valueToEncode = (Math.abs(value) << 1) + signBit;
   while (valueToEncode || !answer) {
     let nextChunk = valueToEncode & VLQ_VALUE_MASK;
@@ -16774,7 +16852,7 @@ var base64Encode = function(src) {
 };
 var vlqTable = new Uint8Array(128);
 var vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-(function() {
+{
   let i = 0;
   let l = vlqTable.length;
   while (i < l) {
@@ -16783,14 +16861,11 @@ var vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
   }
   i = 0;
   l = vlqChars.length;
-  const results = [];
   while (i < l) {
     vlqTable[vlqChars.charCodeAt(i)] = i;
-    results.push(i++);
+    i++;
   }
-  ;
-  return results;
-})();
+}
 var decodeError = function(message) {
   throw new Error(message);
 };