@danielx/civet 0.7.10 → 0.7.11

package/dist/browser.js

@@ -967,27 +967,49 @@ ${body}`;
       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 = ";");
@@ -995,18 +1017,22 @@ ${body}`;
         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;
@@ -1017,7 +1043,7 @@ ${body}`;
     if (!node)
       return;
     switch (node.type) {
-      case "BlockStatement":
+      case "BlockStatement": {
         if (node.expressions.length) {
           if (node.expressions.some(([, exp2]) => isExit(exp2))) {
             return;
@@ -1030,7 +1056,8 @@ ${body}`;
           }
         }
         return;
-      case "WhenClause":
+      }
+      case "WhenClause": {
         if (node.break) {
           node.children.splice(node.children.indexOf(node.break), 1);
         }
@@ -1040,9 +1067,11 @@ ${body}`;
           node.block.expressions.push(wrapWithReturn());
         }
         return;
-      case "DefaultClause":
+      }
+      case "DefaultClause": {
         insertReturn(node.block);
         return;
+      }
     }
     if (!Array.isArray(node))
       return;
@@ -1062,23 +1091,36 @@ ${body}`;
       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([
             "",
@@ -1091,16 +1133,19 @@ ${body}`;
           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);
@@ -1112,18 +1157,23 @@ ${body}`;
             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);
   }
@@ -1212,10 +1262,33 @@ ${body}`;
     }
     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);
     });
@@ -1272,12 +1345,12 @@ ${body}`;
         ...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,
@@ -1298,7 +1371,7 @@ ${body}`;
       expression = {
         ...expression,
         parameters: newParameters,
-        children: expression.children.map(($) => $ === parameters ? newParameters : $)
+        children: expression.children.map(($2) => $2 === parameters ? newParameters : $2)
       };
     }
     return {
@@ -1313,6 +1386,52 @@ ${body}`;
       ]
     };
   }
+  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) {
@@ -1536,8 +1655,8 @@ ${body}`;
       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);
       }
     }
@@ -1819,13 +1938,13 @@ ${body}`;
     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)
@@ -1863,54 +1982,6 @@ ${body}`;
       }
     }
   }
-  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",
@@ -1961,8 +2032,8 @@ ${body}`;
       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);
       }
     }
@@ -2033,11 +2104,11 @@ ${body}`;
   }
   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 "]
@@ -2048,8 +2119,7 @@ ${body}`;
       expressions,
       children: ["{", expressions, "}"],
       bare: false,
-      root: false,
-      parent: void 0
+      root: false
     });
     const parameters = {
       type: "Parameters",
@@ -2058,7 +2128,7 @@ ${body}`;
     };
     const signature = {
       modifier: {
-        async: !!async
+        async: !!async.length
       },
       returnType: void 0
     };
@@ -2401,8 +2471,6 @@ ${body}`;
       }
       return expandedOps;
     }
-    ;
-    return recurse;
   }
   function dotNumericLiteral(literal) {
     if (literal?.type === "Literal" && /^[+-]?(?:0|[1-9](?:_[0-9]|[0-9])*)$/.test(literal.raw)) {
@@ -2919,7 +2987,13 @@ ${body}`;
     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, ";"])
     ];
@@ -3067,9 +3141,18 @@ ${body}`;
         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;
   }
@@ -3560,8 +3643,7 @@ ${body}`;
         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);
@@ -3605,9 +3687,9 @@ ${body}`;
         }
       }
     }
-    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) {
@@ -4276,8 +4358,6 @@ ${body}`;
       debugger;
       throw new Error(`Unknown node ${stringify(node)}`);
     }
-    ;
-    return recurse;
   }
   var generate_default = gen;
   function prune(node) {
@@ -4853,8 +4933,11 @@ ${js}`
       }
       if (results.length > 1) {
         return makeLeftHandSideExpression(results);
+      } else if (results.length) {
+        return results;
+      } else {
+        return ["void 0"];
       }
-      return results;
     } else {
       return blockOrExpression;
     }
@@ -4881,10 +4964,10 @@ ${js}`
       children.push(":void 0");
     }
     children.push(closeParen);
-    return {
+    return makeNode({
       type: "IfExpression",
       children
-    };
+    });
   }
   function expressionizeTypeIf([ws, ifOp, condition, t, e]) {
     const children = [
@@ -7906,16 +7989,8 @@ ${js}`
     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: {
@@ -7926,10 +8001,9 @@ ${js}`
       },
       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];
@@ -9566,7 +9640,6 @@ ${js}`
       name: id?.name,
       parameters,
       returnType: suffix,
-      ts: false,
       async,
       generator,
       modifier: {
@@ -9592,14 +9665,6 @@ ${js}`
         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",
@@ -9771,15 +9836,21 @@ ${js}`
   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 {
@@ -9788,12 +9859,17 @@ ${js}`
     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
     };
   });
@@ -9843,27 +9919,24 @@ ${js}`
     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
       },
@@ -16620,8 +16693,9 @@ ${js}`
     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) {
@@ -16643,7 +16717,8 @@ ${js}`
     const sm = {
       lines: [[]],
       line: 0,
-      column: 0,
+      colOffset: 0,
+      // relative to previous entry
       srcLine: 0,
       srcColumn: 0,
       srcOffset: 0,
@@ -16652,11 +16727,14 @@ ${js}`
     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;
@@ -16693,25 +16771,25 @@ ${js}`
           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;
       }
     };
@@ -16735,8 +16813,8 @@ ${js}`
     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;
         }
@@ -16757,11 +16835,11 @@ ${js}`
     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: {
@@ -16788,12 +16866,12 @@ ${js}`
   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;
@@ -16816,7 +16894,7 @@ ${js}`
   };
   var vlqTable = new Uint8Array(128);
   var vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  (function() {
+  {
     let i = 0;
     let l = vlqTable.length;
     while (i < l) {
@@ -16825,14 +16903,11 @@ ${js}`
     }
     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);
   };