@vercel/python-analysis 0.4.1 → 0.5.0

package/dist/wasm/vercel_python_analysis.js

@@ -3,6 +3,10 @@ export function instantiate(getCoreModule, imports, instantiateCore = WebAssembl
   let dv = new DataView(new ArrayBuffer());
   const dataView = mem => dv.buffer === mem.buffer ? dv : dv = new DataView(mem.buffer);
   
+  const toUint64 = val => BigInt.asUintN(64, BigInt(val));
+  
+  const utf8Decoder = new TextDecoder();
+  
   const utf8Encoder = new TextEncoder();
   let utf8EncodedLen = 0;
   function utf8Encode(s, realloc, memory) {
@@ -709,6 +713,14 @@ const symbolDispose = Symbol.dispose || Symbol.for('dispose');
 
 const handleTables = [];
 
+class ComponentError extends Error {
+  constructor (value) {
+    const enumerable = typeof value !== 'string';
+    super(enumerable ? `${String(value)} (see error.payload)` : value);
+    Object.defineProperty(this, 'payload', { value, enumerable });
+  }
+}
+
 function getErrorPayload(e) {
   if (e && hasOwnProperty.call(e, 'payload')) return e.payload;
   if (e instanceof Error) throw e;
@@ -777,12 +789,14 @@ if (!getCoreModule) getCoreModule = (name) => fetchCompile(new URL(`./${name}`,
 const module0 = getCoreModule('vercel_python_analysis.core.wasm');
 const module1 = getCoreModule('vercel_python_analysis.core2.wasm');
 const module2 = getCoreModule('vercel_python_analysis.core3.wasm');
+const module3 = getCoreModule('vercel_python_analysis.core4.wasm');
 
 const { getEnvironment } = imports['wasi:cli/environment'];
 const { exit } = imports['wasi:cli/exit'];
 const { getStderr } = imports['wasi:cli/stderr'];
 const { Error: Error$1 } = imports['wasi:io/error'];
 const { OutputStream } = imports['wasi:io/streams'];
+const { insecureSeed } = imports['wasi:random/insecure-seed'];
 let gen = (function* _initGenerator () {
   let exports0;
   const handleTable1 = [T_FLAG, 0];
@@ -814,6 +828,7 @@ let gen = (function* _initGenerator () {
     return handle0;
   }
   
+  let exports1;
   
   function trampoline3(arg0) {
     let variant0;
@@ -849,15 +864,34 @@ let gen = (function* _initGenerator () {
     });
   }
   
-  let exports1;
+  let exports2;
   let memory0;
   let realloc0;
+  let realloc1;
+  
+  function trampoline4(arg0) {
+    _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (async? sync, @ enter)');
+    const _interface_call_currentTaskID = startCurrentTask(0, false, 'insecure-seed');
+    const ret = insecureSeed();
+    _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"] [Instruction::CallInterface] (sync, @ post-call)');
+    endCurrentTask(0);
+    var [tuple0_0, tuple0_1] = ret;
+    dataView(memory0).setBigInt64(arg0 + 0, toUint64(tuple0_0), true);
+    dataView(memory0).setBigInt64(arg0 + 8, toUint64(tuple0_1), true);
+    _debugLog('[iface="wasi:random/insecure-seed@0.2.6", function="insecure-seed"][Instruction::Return]', {
+      funcName: 'insecure-seed',
+      paramCount: 0,
+      async: false,
+      postReturn: false
+    });
+  }
+  
   const handleTable0 = [T_FLAG, 0];
   const captureTable0= new Map();
   let captureCnt0 = 0;
   handleTables[0] = handleTable0;
   
-  function trampoline4(arg0, arg1, arg2, arg3) {
+  function trampoline5(arg0, arg1, arg2, arg3) {
     var handle1 = arg0;
     var rep2 = handleTable1[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable1.get(rep2);
@@ -934,7 +968,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline5(arg0, arg1) {
+  function trampoline6(arg0, arg1) {
     var handle1 = arg0;
     var rep2 = handleTable0[(handle1 << 1) + 1] & ~T_FLAG;
     var rsc0 = captureTable0.get(rep2);
@@ -966,7 +1000,7 @@ let gen = (function* _initGenerator () {
   }
   
   
-  function trampoline6(arg0) {
+  function trampoline7(arg0) {
     _debugLog('[iface="wasi:cli/environment@0.2.6", function="get-environment"] [Instruction::CallInterface] (async? sync, @ enter)');
     const _interface_call_currentTaskID = startCurrentTask(0, false, 'get-environment');
     const ret = getEnvironment();
@@ -974,15 +1008,15 @@ let gen = (function* _initGenerator () {
     endCurrentTask(0);
     var vec3 = ret;
     var len3 = vec3.length;
-    var result3 = realloc0(0, 0, 4, len3 * 16);
+    var result3 = realloc1(0, 0, 4, len3 * 16);
     for (let i = 0; i < vec3.length; i++) {
       const e = vec3[i];
       const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
-      var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
+      var ptr1 = utf8Encode(tuple0_0, realloc1, memory0);
       var len1 = utf8EncodedLen;
       dataView(memory0).setUint32(base + 4, len1, true);
       dataView(memory0).setUint32(base + 0, ptr1, true);
-      var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
+      var ptr2 = utf8Encode(tuple0_1, realloc1, memory0);
       var len2 = utf8EncodedLen;
       dataView(memory0).setUint32(base + 12, len2, true);
       dataView(memory0).setUint32(base + 8, ptr2, true);
@@ -997,7 +1031,11 @@ let gen = (function* _initGenerator () {
     });
   }
   
-  let exports2;
+  let exports3;
+  let postReturn0;
+  let postReturn1;
+  let postReturn2;
+  let postReturn3;
   function trampoline0(handle) {
     const handleEntry = rscTableRemove(handleTable1, handle);
     if (handleEntry.own) {
@@ -1024,37 +1062,73 @@ let gen = (function* _initGenerator () {
       }
     }
   }
-  Promise.all([module0, module1, module2]).catch(() => {});
-  ({ exports: exports0 } = yield instantiateCore(yield module1));
+  Promise.all([module0, module1, module2, module3]).catch(() => {});
+  ({ exports: exports0 } = yield instantiateCore(yield module2));
   ({ exports: exports1 } = yield instantiateCore(yield module0, {
-    'wasi:cli/environment@0.2.0': {
-      'get-environment': exports0['2'],
-    },
-    'wasi:cli/exit@0.2.0': {
-      exit: trampoline3,
-    },
     'wasi:cli/stderr@0.2.4': {
       'get-stderr': trampoline1,
     },
     'wasi:io/error@0.2.4': {
-      '[method]error.to-debug-string': exports0['1'],
+      '[method]error.to-debug-string': exports0['2'],
       '[resource-drop]error': trampoline2,
     },
     'wasi:io/streams@0.2.4': {
-      '[method]output-stream.blocking-write-and-flush': exports0['0'],
+      '[method]output-stream.blocking-write-and-flush': exports0['1'],
+      '[resource-drop]output-stream': trampoline0,
+    },
+    'wasi:random/insecure-seed@0.2.4': {
+      'insecure-seed': exports0['0'],
+    },
+    wasi_snapshot_preview1: {
+      environ_get: exports0['3'],
+      environ_sizes_get: exports0['4'],
+      proc_exit: exports0['5'],
+    },
+  }));
+  ({ exports: exports2 } = yield instantiateCore(yield module1, {
+    __main_module__: {
+      cabi_realloc: exports1.cabi_realloc,
+    },
+    env: {
+      memory: exports1.memory,
+    },
+    'wasi:cli/environment@0.2.6': {
+      'get-environment': exports0['6'],
+    },
+    'wasi:cli/exit@0.2.6': {
+      exit: trampoline3,
+    },
+    'wasi:cli/stderr@0.2.6': {
+      'get-stderr': trampoline1,
+    },
+    'wasi:io/error@0.2.6': {
+      '[resource-drop]error': trampoline2,
+    },
+    'wasi:io/streams@0.2.6': {
+      '[method]output-stream.blocking-write-and-flush': exports0['7'],
       '[resource-drop]output-stream': trampoline0,
     },
   }));
   memory0 = exports1.memory;
   realloc0 = exports1.cabi_realloc;
-  ({ exports: exports2 } = yield instantiateCore(yield module2, {
+  realloc1 = exports2.cabi_import_realloc;
+  ({ exports: exports3 } = yield instantiateCore(yield module3, {
     '': {
       $imports: exports0.$imports,
       '0': trampoline4,
       '1': trampoline5,
       '2': trampoline6,
+      '3': exports2.environ_get,
+      '4': exports2.environ_sizes_get,
+      '5': exports2.proc_exit,
+      '6': trampoline7,
+      '7': trampoline5,
     },
   }));
+  postReturn0 = exports1['cabi_post_parse-dist-metadata'];
+  postReturn1 = exports1['cabi_post_parse-record'];
+  postReturn2 = exports1['cabi_post_parse-direct-url'];
+  postReturn3 = exports1['cabi_post_normalize-package-name'];
   let exports1ContainsAppOrHandler;
   
   function containsAppOrHandler(arg0) {
@@ -1078,9 +1152,649 @@ let gen = (function* _initGenerator () {
     });
     return bool1 == 0 ? false : (bool1 == 1 ? true : throwInvalidBool());
   }
+  let exports1ParseDistMetadata;
+  
+  function parseDistMetadata(arg0) {
+    var val0 = arg0;
+    var len0 = val0.byteLength;
+    var ptr0 = realloc0(0, 0, 1, len0 * 1);
+    var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
+    (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
+    _debugLog('[iface="parse-dist-metadata", function="parse-dist-metadata"][Instruction::CallWasm] enter', {
+      funcName: 'parse-dist-metadata',
+      paramCount: 2,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ParseDistMetadata');
+    const ret = exports1ParseDistMetadata(ptr0, len0);
+    endCurrentTask(0);
+    let variant40;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        var ptr1 = dataView(memory0).getUint32(ret + 4, true);
+        var len1 = dataView(memory0).getUint32(ret + 8, true);
+        var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+        var ptr2 = dataView(memory0).getUint32(ret + 12, true);
+        var len2 = dataView(memory0).getUint32(ret + 16, true);
+        var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+        var ptr3 = dataView(memory0).getUint32(ret + 20, true);
+        var len3 = dataView(memory0).getUint32(ret + 24, true);
+        var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+        let variant5;
+        switch (dataView(memory0).getUint8(ret + 28, true)) {
+          case 0: {
+            variant5 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr4 = dataView(memory0).getUint32(ret + 32, true);
+            var len4 = dataView(memory0).getUint32(ret + 36, true);
+            var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+            variant5 = result4;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant7;
+        switch (dataView(memory0).getUint8(ret + 40, true)) {
+          case 0: {
+            variant7 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr6 = dataView(memory0).getUint32(ret + 44, true);
+            var len6 = dataView(memory0).getUint32(ret + 48, true);
+            var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+            variant7 = result6;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant9;
+        switch (dataView(memory0).getUint8(ret + 52, true)) {
+          case 0: {
+            variant9 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr8 = dataView(memory0).getUint32(ret + 56, true);
+            var len8 = dataView(memory0).getUint32(ret + 60, true);
+            var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+            variant9 = result8;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var len11 = dataView(memory0).getUint32(ret + 68, true);
+        var base11 = dataView(memory0).getUint32(ret + 64, true);
+        var result11 = [];
+        for (let i = 0; i < len11; i++) {
+          const base = base11 + i * 8;
+          var ptr10 = dataView(memory0).getUint32(base + 0, true);
+          var len10 = dataView(memory0).getUint32(base + 4, true);
+          var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+          result11.push(result10);
+        }
+        let variant13;
+        switch (dataView(memory0).getUint8(ret + 72, true)) {
+          case 0: {
+            variant13 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr12 = dataView(memory0).getUint32(ret + 76, true);
+            var len12 = dataView(memory0).getUint32(ret + 80, true);
+            var result12 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr12, len12));
+            variant13 = result12;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var len15 = dataView(memory0).getUint32(ret + 88, true);
+        var base15 = dataView(memory0).getUint32(ret + 84, true);
+        var result15 = [];
+        for (let i = 0; i < len15; i++) {
+          const base = base15 + i * 8;
+          var ptr14 = dataView(memory0).getUint32(base + 0, true);
+          var len14 = dataView(memory0).getUint32(base + 4, true);
+          var result14 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr14, len14));
+          result15.push(result14);
+        }
+        let variant17;
+        switch (dataView(memory0).getUint8(ret + 92, true)) {
+          case 0: {
+            variant17 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr16 = dataView(memory0).getUint32(ret + 96, true);
+            var len16 = dataView(memory0).getUint32(ret + 100, true);
+            var result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
+            variant17 = result16;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant19;
+        switch (dataView(memory0).getUint8(ret + 104, true)) {
+          case 0: {
+            variant19 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr18 = dataView(memory0).getUint32(ret + 108, true);
+            var len18 = dataView(memory0).getUint32(ret + 112, true);
+            var result18 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr18, len18));
+            variant19 = result18;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant21;
+        switch (dataView(memory0).getUint8(ret + 116, true)) {
+          case 0: {
+            variant21 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr20 = dataView(memory0).getUint32(ret + 120, true);
+            var len20 = dataView(memory0).getUint32(ret + 124, true);
+            var result20 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr20, len20));
+            variant21 = result20;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant23;
+        switch (dataView(memory0).getUint8(ret + 128, true)) {
+          case 0: {
+            variant23 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr22 = dataView(memory0).getUint32(ret + 132, true);
+            var len22 = dataView(memory0).getUint32(ret + 136, true);
+            var result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
+            variant23 = result22;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant25;
+        switch (dataView(memory0).getUint8(ret + 140, true)) {
+          case 0: {
+            variant25 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr24 = dataView(memory0).getUint32(ret + 144, true);
+            var len24 = dataView(memory0).getUint32(ret + 148, true);
+            var result24 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr24, len24));
+            variant25 = result24;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        let variant27;
+        switch (dataView(memory0).getUint8(ret + 152, true)) {
+          case 0: {
+            variant27 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr26 = dataView(memory0).getUint32(ret + 156, true);
+            var len26 = dataView(memory0).getUint32(ret + 160, true);
+            var result26 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr26, len26));
+            variant27 = result26;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var len29 = dataView(memory0).getUint32(ret + 168, true);
+        var base29 = dataView(memory0).getUint32(ret + 164, true);
+        var result29 = [];
+        for (let i = 0; i < len29; i++) {
+          const base = base29 + i * 8;
+          var ptr28 = dataView(memory0).getUint32(base + 0, true);
+          var len28 = dataView(memory0).getUint32(base + 4, true);
+          var result28 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr28, len28));
+          result29.push(result28);
+        }
+        let variant31;
+        switch (dataView(memory0).getUint8(ret + 172, true)) {
+          case 0: {
+            variant31 = undefined;
+            break;
+          }
+          case 1: {
+            var ptr30 = dataView(memory0).getUint32(ret + 176, true);
+            var len30 = dataView(memory0).getUint32(ret + 180, true);
+            var result30 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr30, len30));
+            variant31 = result30;
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for option');
+          }
+        }
+        var len34 = dataView(memory0).getUint32(ret + 188, true);
+        var base34 = dataView(memory0).getUint32(ret + 184, true);
+        var result34 = [];
+        for (let i = 0; i < len34; i++) {
+          const base = base34 + i * 16;
+          var ptr32 = dataView(memory0).getUint32(base + 0, true);
+          var len32 = dataView(memory0).getUint32(base + 4, true);
+          var result32 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr32, len32));
+          var ptr33 = dataView(memory0).getUint32(base + 8, true);
+          var len33 = dataView(memory0).getUint32(base + 12, true);
+          var result33 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr33, len33));
+          result34.push([result32, result33]);
+        }
+        var len36 = dataView(memory0).getUint32(ret + 196, true);
+        var base36 = dataView(memory0).getUint32(ret + 192, true);
+        var result36 = [];
+        for (let i = 0; i < len36; i++) {
+          const base = base36 + i * 8;
+          var ptr35 = dataView(memory0).getUint32(base + 0, true);
+          var len35 = dataView(memory0).getUint32(base + 4, true);
+          var result35 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr35, len35));
+          result36.push(result35);
+        }
+        var len38 = dataView(memory0).getUint32(ret + 204, true);
+        var base38 = dataView(memory0).getUint32(ret + 200, true);
+        var result38 = [];
+        for (let i = 0; i < len38; i++) {
+          const base = base38 + i * 8;
+          var ptr37 = dataView(memory0).getUint32(base + 0, true);
+          var len37 = dataView(memory0).getUint32(base + 4, true);
+          var result37 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr37, len37));
+          result38.push(result37);
+        }
+        variant40= {
+          tag: 'ok',
+          val: {
+            metadataVersion: result1,
+            name: result2,
+            version: result3,
+            summary: variant5,
+            description: variant7,
+            descriptionContentType: variant9,
+            requiresDist: result11,
+            requiresPython: variant13,
+            providesExtra: result15,
+            author: variant17,
+            authorEmail: variant19,
+            maintainer: variant21,
+            maintainerEmail: variant23,
+            license: variant25,
+            licenseExpression: variant27,
+            classifiers: result29,
+            homePage: variant31,
+            projectUrls: result34,
+            platforms: result36,
+            dynamic: result38,
+          }
+        };
+        break;
+      }
+      case 1: {
+        var ptr39 = dataView(memory0).getUint32(ret + 4, true);
+        var len39 = dataView(memory0).getUint32(ret + 8, true);
+        var result39 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr39, len39));
+        variant40= {
+          tag: 'err',
+          val: result39
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="parse-dist-metadata", function="parse-dist-metadata"][Instruction::Return]', {
+      funcName: 'parse-dist-metadata',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant40;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn0(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
+  }
+  let exports1ParseRecord;
+  
+  function parseRecord(arg0) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    _debugLog('[iface="parse-record", function="parse-record"][Instruction::CallWasm] enter', {
+      funcName: 'parse-record',
+      paramCount: 2,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ParseRecord');
+    const ret = exports1ParseRecord(ptr0, len0);
+    endCurrentTask(0);
+    let variant7;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        var len5 = dataView(memory0).getUint32(ret + 8, true);
+        var base5 = dataView(memory0).getUint32(ret + 4, true);
+        var result5 = [];
+        for (let i = 0; i < len5; i++) {
+          const base = base5 + i * 40;
+          var ptr1 = dataView(memory0).getUint32(base + 0, true);
+          var len1 = dataView(memory0).getUint32(base + 4, true);
+          var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+          let variant3;
+          switch (dataView(memory0).getUint8(base + 8, true)) {
+            case 0: {
+              variant3 = undefined;
+              break;
+            }
+            case 1: {
+              var ptr2 = dataView(memory0).getUint32(base + 12, true);
+              var len2 = dataView(memory0).getUint32(base + 16, true);
+              var result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
+              variant3 = result2;
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          let variant4;
+          switch (dataView(memory0).getUint8(base + 24, true)) {
+            case 0: {
+              variant4 = undefined;
+              break;
+            }
+            case 1: {
+              variant4 = BigInt.asUintN(64, dataView(memory0).getBigInt64(base + 32, true));
+              break;
+            }
+            default: {
+              throw new TypeError('invalid variant discriminant for option');
+            }
+          }
+          result5.push({
+            path: result1,
+            hash: variant3,
+            size: variant4,
+          });
+        }
+        variant7= {
+          tag: 'ok',
+          val: result5
+        };
+        break;
+      }
+      case 1: {
+        var ptr6 = dataView(memory0).getUint32(ret + 4, true);
+        var len6 = dataView(memory0).getUint32(ret + 8, true);
+        var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+        variant7= {
+          tag: 'err',
+          val: result6
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="parse-record", function="parse-record"][Instruction::Return]', {
+      funcName: 'parse-record',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant7;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn1(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
+  }
+  let exports1ParseDirectUrl;
+  
+  function parseDirectUrl(arg0) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    _debugLog('[iface="parse-direct-url", function="parse-direct-url"][Instruction::CallWasm] enter', {
+      funcName: 'parse-direct-url',
+      paramCount: 2,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1ParseDirectUrl');
+    const ret = exports1ParseDirectUrl(ptr0, len0);
+    endCurrentTask(0);
+    let variant14;
+    switch (dataView(memory0).getUint8(ret + 0, true)) {
+      case 0: {
+        let variant12;
+        switch (dataView(memory0).getUint8(ret + 4, true)) {
+          case 0: {
+            var ptr1 = dataView(memory0).getUint32(ret + 8, true);
+            var len1 = dataView(memory0).getUint32(ret + 12, true);
+            var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+            var bool2 = dataView(memory0).getUint8(ret + 16, true);
+            variant12= {
+              tag: 'local-directory',
+              val: {
+                url: result1,
+                editable: bool2 == 0 ? false : (bool2 == 1 ? true : throwInvalidBool()),
+              }
+            };
+            break;
+          }
+          case 1: {
+            var ptr3 = dataView(memory0).getUint32(ret + 8, true);
+            var len3 = dataView(memory0).getUint32(ret + 12, true);
+            var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
+            let variant5;
+            switch (dataView(memory0).getUint8(ret + 16, true)) {
+              case 0: {
+                variant5 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr4 = dataView(memory0).getUint32(ret + 20, true);
+                var len4 = dataView(memory0).getUint32(ret + 24, true);
+                var result4 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr4, len4));
+                variant5 = result4;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            variant12= {
+              tag: 'archive',
+              val: {
+                url: result3,
+                hash: variant5,
+              }
+            };
+            break;
+          }
+          case 2: {
+            var ptr6 = dataView(memory0).getUint32(ret + 8, true);
+            var len6 = dataView(memory0).getUint32(ret + 12, true);
+            var result6 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr6, len6));
+            var ptr7 = dataView(memory0).getUint32(ret + 16, true);
+            var len7 = dataView(memory0).getUint32(ret + 20, true);
+            var result7 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr7, len7));
+            let variant9;
+            switch (dataView(memory0).getUint8(ret + 24, true)) {
+              case 0: {
+                variant9 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr8 = dataView(memory0).getUint32(ret + 28, true);
+                var len8 = dataView(memory0).getUint32(ret + 32, true);
+                var result8 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr8, len8));
+                variant9 = result8;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            let variant11;
+            switch (dataView(memory0).getUint8(ret + 36, true)) {
+              case 0: {
+                variant11 = undefined;
+                break;
+              }
+              case 1: {
+                var ptr10 = dataView(memory0).getUint32(ret + 40, true);
+                var len10 = dataView(memory0).getUint32(ret + 44, true);
+                var result10 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr10, len10));
+                variant11 = result10;
+                break;
+              }
+              default: {
+                throw new TypeError('invalid variant discriminant for option');
+              }
+            }
+            variant12= {
+              tag: 'vcs',
+              val: {
+                url: result6,
+                vcs: result7,
+                commitId: variant9,
+                requestedRevision: variant11,
+              }
+            };
+            break;
+          }
+          default: {
+            throw new TypeError('invalid variant discriminant for DirectUrlInfo');
+          }
+        }
+        variant14= {
+          tag: 'ok',
+          val: variant12
+        };
+        break;
+      }
+      case 1: {
+        var ptr13 = dataView(memory0).getUint32(ret + 4, true);
+        var len13 = dataView(memory0).getUint32(ret + 8, true);
+        var result13 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr13, len13));
+        variant14= {
+          tag: 'err',
+          val: result13
+        };
+        break;
+      }
+      default: {
+        throw new TypeError('invalid variant discriminant for expected');
+      }
+    }
+    _debugLog('[iface="parse-direct-url", function="parse-direct-url"][Instruction::Return]', {
+      funcName: 'parse-direct-url',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = variant14;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn2(ret);
+    cstate.mayLeave = true;
+    
+    
+    
+    if (typeof retCopy === 'object' && retCopy.tag === 'err') {
+      throw new ComponentError(retCopy.val);
+    }
+    return retCopy.val;
+    
+  }
+  let exports1NormalizePackageName;
+  
+  function normalizePackageName(arg0) {
+    var ptr0 = utf8Encode(arg0, realloc0, memory0);
+    var len0 = utf8EncodedLen;
+    _debugLog('[iface="normalize-package-name", function="normalize-package-name"][Instruction::CallWasm] enter', {
+      funcName: 'normalize-package-name',
+      paramCount: 2,
+      async: false,
+      postReturn: true,
+    });
+    const _wasm_call_currentTaskID = startCurrentTask(0, false, 'exports1NormalizePackageName');
+    const ret = exports1NormalizePackageName(ptr0, len0);
+    endCurrentTask(0);
+    var ptr1 = dataView(memory0).getUint32(ret + 0, true);
+    var len1 = dataView(memory0).getUint32(ret + 4, true);
+    var result1 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr1, len1));
+    _debugLog('[iface="normalize-package-name", function="normalize-package-name"][Instruction::Return]', {
+      funcName: 'normalize-package-name',
+      paramCount: 1,
+      async: false,
+      postReturn: true
+    });
+    const retCopy = result1;
+    
+    let cstate = getOrCreateAsyncState(0);
+    cstate.mayLeave = false;
+    postReturn3(ret);
+    cstate.mayLeave = true;
+    return retCopy;
+    
+  }
   exports1ContainsAppOrHandler = exports1['contains-app-or-handler'];
+  exports1ParseDistMetadata = exports1['parse-dist-metadata'];
+  exports1ParseRecord = exports1['parse-record'];
+  exports1ParseDirectUrl = exports1['parse-direct-url'];
+  exports1NormalizePackageName = exports1['normalize-package-name'];
   
-  return { containsAppOrHandler,  };
+  return { containsAppOrHandler, normalizePackageName, parseDirectUrl, parseDistMetadata, parseRecord,  };
 })();
 let promise, resolve, reject;
 function runNext (value) {