@ricsam/quickjs-test-utils 1.0.18 → 1.0.19

package/dist/cjs/index.cjs

@@ -34,6 +34,7 @@ __export(exports_src, {
   useFetchTestContext: () => import_fetch_context.useFetchTestContext,
   typecheckQuickJSCode: () => import_typecheck.typecheckQuickJSCode,
   startIntegrationServer: () => import_integration_server.startIntegrationServer,
+  runTestCode: () => import_native_input_test.runTestCode,
   formatTypecheckErrors: () => import_typecheck.formatTypecheckErrors,
   evalCodeAsync: () => import_eval.evalCodeAsync,
   evalCode: () => import_eval.evalCode,
@@ -50,9 +51,10 @@ module.exports = __toCommonJS(exports_src);
 var import_context = require("./context.cjs");
 var import_fetch_context = require("./fetch-context.cjs");
 var import_eval = require("./eval.cjs");
+var import_native_input_test = require("./native-input-test.cjs");
 var import_integration_server = require("./integration-server.cjs");
 var import_typecheck = require("./typecheck.cjs");
 var import_quickjs_types = require("./quickjs-types.cjs");
 })
 
-//# debugId=58D73AEF6D5595F264756E2164756E21
+//# debugId=2D2B04FA8DA88D0664756E2164756E21

package/dist/cjs/index.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../src/index.ts"],
   "sourcesContent": [
-    "export {\n  createTestContext,\n  disposeTestContext,\n  useTestContext,\n  type TestContext,\n} from \"./context.cjs\";\n\nexport {\n  createFetchTestContext,\n  disposeFetchTestContext,\n  useFetchTestContext,\n  type FetchTestContext,\n  type CreateFetchTestContextOptions,\n} from \"./fetch-context.cjs\";\n\nexport { evalCode, evalCodeAsync } from \"./eval.cjs\";\n\nexport {\n  startIntegrationServer,\n  type IntegrationTestServer,\n  type StartIntegrationServerOptions,\n} from \"./integration-server.cjs\";\n\nexport {\n  typecheckQuickJSCode,\n  formatTypecheckErrors,\n  type TypecheckResult,\n  type TypecheckError,\n  type TypecheckOptions,\n  type LibraryTypes,\n  type LibraryTypeFile,\n} from \"./typecheck.cjs\";\n\nexport {\n  CORE_TYPES,\n  FETCH_TYPES,\n  FS_TYPES,\n  TYPE_DEFINITIONS,\n  type TypeDefinitionKey,\n} from \"./quickjs-types.cjs\";\n\n// For fs and runtime contexts, import from subpaths:\n// import { createFsTestContext } from \"@ricsam/quickjs-test-utils/fs\";\n// import { createRuntimeTestContext } from \"@ricsam/quickjs-test-utils/runtime\";\n"
+    "export {\n  createTestContext,\n  disposeTestContext,\n  useTestContext,\n  type TestContext,\n} from \"./context.cjs\";\n\nexport {\n  createFetchTestContext,\n  disposeFetchTestContext,\n  useFetchTestContext,\n  type FetchTestContext,\n  type CreateFetchTestContextOptions,\n} from \"./fetch-context.cjs\";\n\nexport { evalCode, evalCodeAsync } from \"./eval.cjs\";\n\nexport {\n  runTestCode,\n  type TestRuntime,\n  type TestRunner,\n} from \"./native-input-test.cjs\";\n\nexport {\n  startIntegrationServer,\n  type IntegrationTestServer,\n  type StartIntegrationServerOptions,\n} from \"./integration-server.cjs\";\n\nexport {\n  typecheckQuickJSCode,\n  formatTypecheckErrors,\n  type TypecheckResult,\n  type TypecheckError,\n  type TypecheckOptions,\n  type LibraryTypes,\n  type LibraryTypeFile,\n} from \"./typecheck.cjs\";\n\nexport {\n  CORE_TYPES,\n  FETCH_TYPES,\n  FS_TYPES,\n  TYPE_DEFINITIONS,\n  type TypeDefinitionKey,\n} from \"./quickjs-types.cjs\";\n\n// For fs and runtime contexts, import from subpaths:\n// import { createFsTestContext } from \"@ricsam/quickjs-test-utils/fs\";\n// import { createRuntimeTestContext } from \"@ricsam/quickjs-test-utils/runtime\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IALP;AAaO,IANP;AAQwC,IAAxC;AAMO,IAJP;AAcO,IARP;AAgBO,IANP;",
-  "debugId": "58D73AEF6D5595F264756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IALP;AAaO,IANP;AAQwC,IAAxC;AAMO,IAJP;AAUO,IAJP;AAcO,IARP;AAgBO,IANP;",
+  "debugId": "2D2B04FA8DA88D0664756E2164756E21",
   "names": []
 }

package/dist/cjs/native-input-test.cjs

@@ -0,0 +1,565 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-utils/src/native-input-test.ts
+var exports_native_input_test = {};
+__export(exports_native_input_test, {
+  runTestCode: () => runTestCode
+});
+module.exports = __toCommonJS(exports_native_input_test);
+var import_quickjs_core = require("@ricsam/quickjs-core");
+function runTestCode(context, code) {
+  return {
+    input(inputs) {
+      const logs = {};
+      const logFn = context.newFunction("log", (tagHandle, valueHandle) => {
+        const tag = context.getString(tagHandle);
+        const value = unmarshalWithClassConversion(context, valueHandle);
+        logs[tag] = value;
+      });
+      context.setProp(context.global, "log", logFn);
+      logFn.dispose();
+      const inputHandle = marshalWithClassConversion(context, inputs);
+      context.setProp(context.global, "testingInput", inputHandle);
+      inputHandle.dispose();
+      const result = context.evalCode(code);
+      let returnValue = undefined;
+      if (result.error) {
+        const error = context.dump(result.error);
+        result.error.dispose();
+        context.setProp(context.global, "testingInput", context.undefined);
+        context.setProp(context.global, "log", context.undefined);
+        throw new Error(`Test code failed: ${JSON.stringify(error)}`);
+      } else {
+        returnValue = context.dump(result.value);
+        result.value.dispose();
+      }
+      context.setProp(context.global, "testingInput", context.undefined);
+      context.setProp(context.global, "log", context.undefined);
+      return { logs, result: returnValue };
+    }
+  };
+}
+function marshalWithClassConversion(context, value) {
+  if (value instanceof Headers) {
+    return createQJSHeadersFromNative(context, value);
+  }
+  if (value instanceof Request) {
+    return createQJSRequestFromNative(context, value);
+  }
+  if (value instanceof Response) {
+    return createQJSResponseFromNative(context, value);
+  }
+  if (value instanceof URL) {
+    return createQJSURLFromNative(context, value);
+  }
+  if (value instanceof Blob && !(value instanceof File)) {
+    return createQJSBlobFromNative(context, value);
+  }
+  if (value instanceof File) {
+    return createQJSFileFromNative(context, value);
+  }
+  if (value instanceof FormData) {
+    return createQJSFormDataFromNative(context, value);
+  }
+  if (Array.isArray(value)) {
+    const arr = context.newArray();
+    for (let i = 0;i < value.length; i++) {
+      const itemHandle = marshalWithClassConversion(context, value[i]);
+      context.setProp(arr, i, itemHandle);
+      itemHandle.dispose();
+    }
+    return arr;
+  }
+  if (value && typeof value === "object" && value.constructor === Object) {
+    const obj = context.newObject();
+    for (const [key, val] of Object.entries(value)) {
+      const valHandle = marshalWithClassConversion(context, val);
+      context.setProp(obj, key, valHandle);
+      valHandle.dispose();
+    }
+    return obj;
+  }
+  return import_quickjs_core.marshal(context, value);
+}
+function createQJSHeadersFromNative(context, native) {
+  const pairs = [];
+  native.forEach((value, key) => {
+    pairs.push([key, value]);
+  });
+  const pairsJson = JSON.stringify(pairs);
+  const result = context.evalCode(`new Headers(${pairsJson})`);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create Headers from native: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createQJSRequestFromNative(context, native) {
+  const headersHandle = createQJSHeadersFromNative(context, native.headers);
+  context.setProp(context.global, "__nativeRequestHeaders__", headersHandle);
+  headersHandle.dispose();
+  const urlJson = JSON.stringify(native.url);
+  const methodJson = JSON.stringify(native.method);
+  const modeJson = JSON.stringify(native.mode);
+  const credentialsJson = JSON.stringify(native.credentials);
+  const cacheJson = JSON.stringify(native.cache);
+  const redirectJson = JSON.stringify(native.redirect);
+  const referrerJson = JSON.stringify(native.referrer);
+  const referrerPolicyJson = JSON.stringify(native.referrerPolicy);
+  const integrityJson = JSON.stringify(native.integrity);
+  const result = context.evalCode(`
+    (function() {
+      const req = new Request(${urlJson}, {
+        method: ${methodJson},
+        headers: __nativeRequestHeaders__,
+        mode: ${modeJson},
+        credentials: ${credentialsJson},
+        cache: ${cacheJson},
+        redirect: ${redirectJson},
+        referrer: ${referrerJson},
+        referrerPolicy: ${referrerPolicyJson},
+        integrity: ${integrityJson},
+      });
+      delete globalThis.__nativeRequestHeaders__;
+      return req;
+    })()
+  `);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create Request from native: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createQJSResponseFromNative(context, native) {
+  const headersHandle = createQJSHeadersFromNative(context, native.headers);
+  context.setProp(context.global, "__nativeResponseHeaders__", headersHandle);
+  headersHandle.dispose();
+  const statusJson = JSON.stringify(native.status);
+  const statusTextJson = JSON.stringify(native.statusText);
+  const result = context.evalCode(`
+    (function() {
+      const res = new Response(null, {
+        status: ${statusJson},
+        statusText: ${statusTextJson},
+        headers: __nativeResponseHeaders__,
+      });
+      delete globalThis.__nativeResponseHeaders__;
+      return res;
+    })()
+  `);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create Response from native: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createQJSURLFromNative(context, native) {
+  const hrefJson = JSON.stringify(native.href);
+  const result = context.evalCode(`new URL(${hrefJson})`);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create URL from native: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createQJSBlobFromNative(context, native) {
+  const typeJson = JSON.stringify(native.type);
+  const result = context.evalCode(`new Blob([], { type: ${typeJson} })`);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create Blob from native: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createQJSFileFromNative(context, native) {
+  const nameJson = JSON.stringify(native.name);
+  const typeJson = JSON.stringify(native.type);
+  const lastModifiedJson = JSON.stringify(native.lastModified);
+  const result = context.evalCode(`
+    new File([], ${nameJson}, { type: ${typeJson}, lastModified: ${lastModifiedJson} })
+  `);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create File from native: ${JSON.stringify(err)}`);
+  }
+  return result.value;
+}
+function createQJSFormDataFromNative(context, native) {
+  const result = context.evalCode(`new FormData()`);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create FormData from native: ${JSON.stringify(err)}`);
+  }
+  const formDataHandle = result.value;
+  for (const [key, entryValue] of native.entries()) {
+    const keyJson = JSON.stringify(key);
+    if (typeof entryValue !== "string") {
+      const fileValue = entryValue;
+      const nameJson = JSON.stringify(fileValue.name);
+      const typeJson = JSON.stringify(fileValue.type);
+      const appendResult = context.evalCode(`
+        (function(fd) {
+          const file = new File([], ${nameJson}, { type: ${typeJson} });
+          fd.append(${keyJson}, file);
+          return fd;
+        })
+      `);
+      if (appendResult.error) {
+        appendResult.error.dispose();
+        formDataHandle.dispose();
+        throw new Error("Failed to create append function for File");
+      }
+      const appendFn = appendResult.value;
+      const callResult = context.callFunction(appendFn, context.undefined, formDataHandle);
+      appendFn.dispose();
+      if (callResult.error) {
+        callResult.error.dispose();
+        formDataHandle.dispose();
+        throw new Error("Failed to append File to FormData");
+      }
+      callResult.value.dispose();
+    } else {
+      const valueJson = JSON.stringify(entryValue);
+      const appendResult = context.evalCode(`
+        (function(fd) {
+          fd.append(${keyJson}, ${valueJson});
+          return fd;
+        })
+      `);
+      if (appendResult.error) {
+        appendResult.error.dispose();
+        formDataHandle.dispose();
+        throw new Error("Failed to create append function");
+      }
+      const appendFn = appendResult.value;
+      const callResult = context.callFunction(appendFn, context.undefined, formDataHandle);
+      appendFn.dispose();
+      if (callResult.error) {
+        callResult.error.dispose();
+        formDataHandle.dispose();
+        throw new Error("Failed to append to FormData");
+      }
+      callResult.value.dispose();
+    }
+  }
+  return formDataHandle;
+}
+function unmarshalWithClassConversion(context, handle) {
+  if (isInstanceOf(context, handle, "Headers")) {
+    return createNativeHeadersFromQJS(context, handle);
+  }
+  if (isInstanceOf(context, handle, "Request")) {
+    return createNativeRequestFromQJS(context, handle);
+  }
+  if (isInstanceOf(context, handle, "Response")) {
+    return createNativeResponseFromQJS(context, handle);
+  }
+  if (isInstanceOf(context, handle, "URL")) {
+    return createNativeURLFromQJS(context, handle);
+  }
+  if (isInstanceOf(context, handle, "File")) {
+    return createNativeFileFromQJS(context, handle);
+  }
+  if (isInstanceOf(context, handle, "Blob")) {
+    return createNativeBlobFromQJS(context, handle);
+  }
+  if (isInstanceOf(context, handle, "FormData")) {
+    return createNativeFormDataFromQJS(context, handle);
+  }
+  const typeofResult = context.typeof(handle);
+  if (typeofResult === "object") {
+    const isArrayResult = context.evalCode(`(function(obj) { return Array.isArray(obj); })`);
+    if (!isArrayResult.error) {
+      const checkResult = context.callFunction(isArrayResult.value, context.undefined, handle);
+      isArrayResult.value.dispose();
+      if (!checkResult.error && context.dump(checkResult.value) === true) {
+        checkResult.value.dispose();
+        return unmarshalArray(context, handle);
+      }
+      if (checkResult.error)
+        checkResult.error.dispose();
+      else if (checkResult.value)
+        checkResult.value.dispose();
+    } else {
+      isArrayResult.error.dispose();
+    }
+    const isPlainObjectResult = context.evalCode(`(function(obj) {
+      return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+    })`);
+    if (!isPlainObjectResult.error) {
+      const checkResult = context.callFunction(isPlainObjectResult.value, context.undefined, handle);
+      isPlainObjectResult.value.dispose();
+      if (!checkResult.error && context.dump(checkResult.value) === true) {
+        checkResult.value.dispose();
+        return unmarshalObject(context, handle);
+      }
+      if (checkResult.error)
+        checkResult.error.dispose();
+      else if (checkResult.value)
+        checkResult.value.dispose();
+    } else {
+      isPlainObjectResult.error.dispose();
+    }
+  }
+  return context.dump(handle);
+}
+function isInstanceOf(context, handle, className) {
+  const checkResult = context.evalCode(`(function(obj) { return obj instanceof ${className}; })`);
+  if (checkResult.error) {
+    checkResult.error.dispose();
+    return false;
+  }
+  const result = context.callFunction(checkResult.value, context.undefined, handle);
+  checkResult.value.dispose();
+  if (result.error) {
+    result.error.dispose();
+    return false;
+  }
+  const isInstance = context.dump(result.value) === true;
+  result.value.dispose();
+  return isInstance;
+}
+function unmarshalArray(context, handle) {
+  const lengthHandle = context.getProp(handle, "length");
+  const length = context.dump(lengthHandle);
+  lengthHandle.dispose();
+  const result = [];
+  for (let i = 0;i < length; i++) {
+    const itemHandle = context.getProp(handle, i);
+    result.push(unmarshalWithClassConversion(context, itemHandle));
+    itemHandle.dispose();
+  }
+  return result;
+}
+function unmarshalObject(context, handle) {
+  const keysResult = context.evalCode(`(function(obj) { return Object.keys(obj); })`);
+  if (keysResult.error) {
+    keysResult.error.dispose();
+    return context.dump(handle);
+  }
+  const keysCallResult = context.callFunction(keysResult.value, context.undefined, handle);
+  keysResult.value.dispose();
+  if (keysCallResult.error) {
+    keysCallResult.error.dispose();
+    return context.dump(handle);
+  }
+  const keys = context.dump(keysCallResult.value);
+  keysCallResult.value.dispose();
+  const result = {};
+  for (const key of keys) {
+    const propHandle = context.getProp(handle, key);
+    result[key] = unmarshalWithClassConversion(context, propHandle);
+    propHandle.dispose();
+  }
+  return result;
+}
+function createNativeHeadersFromQJS(context, qjsHandle) {
+  const extractResult = context.evalCode(`
+    (function(headers) {
+      const pairs = [];
+      for (const [key, value] of headers) {
+        pairs.push([key, value]);
+      }
+      return pairs;
+    })
+  `);
+  if (extractResult.error) {
+    extractResult.error.dispose();
+    throw new Error("Failed to create extract function for Headers");
+  }
+  const result = context.callFunction(extractResult.value, context.undefined, qjsHandle);
+  extractResult.value.dispose();
+  if (result.error) {
+    result.error.dispose();
+    throw new Error("Failed to call header extraction function");
+  }
+  const pairs = context.dump(result.value);
+  result.value.dispose();
+  const native = new Headers;
+  for (const [key, value] of pairs) {
+    native.append(key, value);
+  }
+  return native;
+}
+function createNativeRequestFromQJS(context, qjsHandle) {
+  const extractResult = context.evalCode(`
+    (function(req) {
+      const headers = [];
+      for (const [key, value] of req.headers) {
+        headers.push([key, value]);
+      }
+      return {
+        url: req.url,
+        method: req.method,
+        headers: headers,
+        mode: req.mode,
+        credentials: req.credentials,
+        cache: req.cache,
+        redirect: req.redirect,
+        referrer: req.referrer,
+        referrerPolicy: req.referrerPolicy,
+        integrity: req.integrity,
+      };
+    })
+  `);
+  if (extractResult.error) {
+    extractResult.error.dispose();
+    throw new Error("Failed to create extract function for Request");
+  }
+  const result = context.callFunction(extractResult.value, context.undefined, qjsHandle);
+  extractResult.value.dispose();
+  if (result.error) {
+    result.error.dispose();
+    throw new Error("Failed to call request extraction function");
+  }
+  const props = context.dump(result.value);
+  result.value.dispose();
+  const headers = new Headers;
+  for (const [key, value] of props.headers) {
+    headers.append(key, value);
+  }
+  return new Request(props.url, {
+    method: props.method,
+    headers,
+    mode: props.mode,
+    credentials: props.credentials,
+    cache: props.cache,
+    redirect: props.redirect,
+    referrer: props.referrer,
+    referrerPolicy: props.referrerPolicy,
+    integrity: props.integrity
+  });
+}
+function createNativeResponseFromQJS(context, qjsHandle) {
+  const extractResult = context.evalCode(`
+    (function(res) {
+      const headers = [];
+      for (const [key, value] of res.headers) {
+        headers.push([key, value]);
+      }
+      return {
+        status: res.status,
+        statusText: res.statusText,
+        headers: headers,
+      };
+    })
+  `);
+  if (extractResult.error) {
+    extractResult.error.dispose();
+    throw new Error("Failed to create extract function for Response");
+  }
+  const result = context.callFunction(extractResult.value, context.undefined, qjsHandle);
+  extractResult.value.dispose();
+  if (result.error) {
+    result.error.dispose();
+    throw new Error("Failed to call response extraction function");
+  }
+  const props = context.dump(result.value);
+  result.value.dispose();
+  const headers = new Headers;
+  for (const [key, value] of props.headers) {
+    headers.append(key, value);
+  }
+  return new Response(null, {
+    status: props.status,
+    statusText: props.statusText,
+    headers
+  });
+}
+function createNativeURLFromQJS(context, qjsHandle) {
+  const hrefHandle = context.getProp(qjsHandle, "href");
+  const href = context.dump(hrefHandle);
+  hrefHandle.dispose();
+  return new URL(href);
+}
+function createNativeBlobFromQJS(context, qjsHandle) {
+  const typeHandle = context.getProp(qjsHandle, "type");
+  const type = context.dump(typeHandle);
+  typeHandle.dispose();
+  return new Blob([], { type });
+}
+function createNativeFileFromQJS(context, qjsHandle) {
+  const nameHandle = context.getProp(qjsHandle, "name");
+  const name = context.dump(nameHandle);
+  nameHandle.dispose();
+  const typeHandle = context.getProp(qjsHandle, "type");
+  const type = context.dump(typeHandle);
+  typeHandle.dispose();
+  const lastModifiedHandle = context.getProp(qjsHandle, "lastModified");
+  const lastModified = context.dump(lastModifiedHandle);
+  lastModifiedHandle.dispose();
+  return new File([], name, { type, lastModified });
+}
+function createNativeFormDataFromQJS(context, qjsHandle) {
+  const extractResult = context.evalCode(`
+    (function(fd) {
+      const entries = [];
+      for (const [key, value] of fd) {
+        if (value instanceof File) {
+          entries.push([key, { type: 'file', name: value.name, fileType: value.type, lastModified: value.lastModified }]);
+        } else {
+          entries.push([key, { type: 'string', value: value }]);
+        }
+      }
+      return entries;
+    })
+  `);
+  if (extractResult.error) {
+    extractResult.error.dispose();
+    throw new Error("Failed to create extract function for FormData");
+  }
+  const result = context.callFunction(extractResult.value, context.undefined, qjsHandle);
+  extractResult.value.dispose();
+  if (result.error) {
+    result.error.dispose();
+    throw new Error("Failed to call formdata extraction function");
+  }
+  const entries = context.dump(result.value);
+  result.value.dispose();
+  const formData = new FormData;
+  for (const [key, entry] of entries) {
+    if (entry.type === "file") {
+      formData.append(key, new File([], entry.name, { type: entry.fileType, lastModified: entry.lastModified }));
+    } else {
+      formData.append(key, entry.value);
+    }
+  }
+  return formData;
+}
+})
+
+//# debugId=A14BDC5D5B1C027164756E2164756E21