arri 0.0.5 → 0.0.6

package/dist/{codegen/index.cjs → shared/arri.38ad6cd0.cjs}

@@ -1,33 +1,31 @@
 'use strict';
 
-const index = require('../shared/arri.e2731572.cjs');
-const module$1 = require('module');
-const url = require('url');
-const path6 = require('path');
+const require$$2 = require('module');
+const require$$7 = require('url');
+const require$$0 = require('path');
 const process4 = require('process');
-const os = require('os');
+const require$$0$2 = require('os');
 const tty = require('tty');
 const fs$1 = require('fs');
 const assert4 = require('assert');
 const fs = require('fs/promises');
 const v8 = require('v8');
-const util = require('util');
-const child_process = require('child_process');
+const require$$0$1 = require('util');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const path6__default = /*#__PURE__*/_interopDefaultCompat(path6);
+const require$$0__default = /*#__PURE__*/_interopDefaultCompat(require$$0);
 const process4__default = /*#__PURE__*/_interopDefaultCompat(process4);
-const os__default = /*#__PURE__*/_interopDefaultCompat(os);
+const require$$0__default$1 = /*#__PURE__*/_interopDefaultCompat(require$$0$2);
 const tty__default = /*#__PURE__*/_interopDefaultCompat(tty);
 const fs__default$1 = /*#__PURE__*/_interopDefaultCompat(fs$1);
 const assert4__default = /*#__PURE__*/_interopDefaultCompat(assert4);
 const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
 const v8__default = /*#__PURE__*/_interopDefaultCompat(v8);
 
-const require$2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('codegen/index.cjs', document.baseURI).href)));
-const __filename$2 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('codegen/index.cjs', document.baseURI).href)));
-const __dirname$1 = path6.dirname(__filename$2);
+const require$2 = require$$2.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
+const __filename$2 = require$$7.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
+const __dirname$1 = require$$0.dirname(__filename$2);
 
 var __create$1 = Object.create;
 var __defProp$2 = Object.defineProperty;
@@ -7791,9 +7789,9 @@ const doc = {
   utils: utils
 };
 
-const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('codegen/index.cjs', document.baseURI).href)));
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('codegen/index.cjs', document.baseURI).href)));
-path6.dirname(__filename$1);
+const require$1 = require$$2.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
+const __filename$1 = require$$7.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('shared/arri.38ad6cd0.cjs', document.baseURI).href)));
+require$$0.dirname(__filename$1);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -21416,7 +21414,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if (process4__default.platform === "win32") {
-    const osRelease = os__default.release().split(".");
+    const osRelease = require$$0__default$1.release().split(".");
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
@@ -26012,10 +26010,10 @@ var partition_default = partition2;
 var import_editorconfig = __toESM(require_src(), 1);
 var import_editorconfig_to_prettier = __toESM(require_editorconfig_to_prettier(), 1);
 var MARKERS = [".git", ".hg"];
-var markerExists = (directory) => MARKERS.some((mark) => fs__default$1.existsSync(path6__default.join(directory, mark)));
+var markerExists = (directory) => MARKERS.some((mark) => fs__default$1.existsSync(require$$0__default.join(directory, mark)));
 function findProjectRoot(directory) {
   while (!markerExists(directory)) {
-    const parentDirectory = path6__default.resolve(directory, "..");
+    const parentDirectory = require$$0__default.resolve(directory, "..");
     if (parentDirectory === directory) {
       break;
     }
@@ -26028,7 +26026,7 @@ var find_project_root_default = findProjectRoot;
 // src/config/resolve-editorconfig.js
 async function loadEditorConfig(filePath) {
   const editorConfig = await import_editorconfig.default.parse(filePath, {
-    root: find_project_root_default(path6__default.dirname(path6__default.resolve(filePath)))
+    root: find_project_root_default(require$$0__default.dirname(require$$0__default.resolve(filePath)))
   });
   const config = (0, import_editorconfig_to_prettier.default)(editorConfig);
   if (config) {
@@ -26042,7 +26040,7 @@ var resolve_editorconfig_default = loadEditorConfig;
 var import_parse_async = __toESM(require_parse_async(), 1);
 var import_parse3 = __toESM(require_parse3(), 1);
 function requireFromFile(id, parent) {
-  const require2 = module$1.createRequire(parent);
+  const require2 = require$$2.createRequire(parent);
   return require2(id);
 }
 var require_from_file_default = requireFromFile;
@@ -26254,7 +26252,7 @@ codes.ERR_INVALID_ARG_VALUE = createError(
    * @param {string} [reason='is invalid']
    */
   (name, value, reason = "is invalid") => {
-    let inspected = util.inspect(value);
+    let inspected = require$$0$1.inspect(value);
     if (inspected.length > 128) {
       inspected = `${inspected.slice(0, 128)}...`;
     }
@@ -26379,7 +26377,7 @@ function getMessage(key, args, self) {
   if (args.length === 0)
     return message;
   args.unshift(message);
-  return Reflect.apply(util.format, null, args);
+  return Reflect.apply(require$$0$1.format, null, args);
 }
 function determineSpecificType(value) {
   if (value === null || value === void 0) {
@@ -26392,9 +26390,9 @@ function determineSpecificType(value) {
     if (value.constructor && value.constructor.name) {
       return `an instance of ${value.constructor.name}`;
     }
-    return `${util.inspect(value, { depth: -1 })}`;
+    return `${require$$0$1.inspect(value, { depth: -1 })}`;
   }
-  let inspected = util.inspect(value, { colors: false });
+  let inspected = require$$0$1.inspect(value, { colors: false });
   if (inspected.length > 28) {
     inspected = `${inspected.slice(0, 25)}...`;
   }
@@ -26405,7 +26403,7 @@ var package_json_reader_default = reader;
 function read(jsonPath) {
   try {
     const string = fs__default$1.readFileSync(
-      path6__default.toNamespacedPath(path6__default.join(path6__default.dirname(jsonPath), "package.json")),
+      require$$0__default.toNamespacedPath(require$$0__default.join(require$$0__default.dirname(jsonPath), "package.json")),
       "utf8"
     );
     return { string };
@@ -26453,7 +26451,7 @@ function getPackageConfig(path9, specifier, base) {
     );
     throw new ERR_INVALID_PACKAGE_CONFIG(
       path9,
-      (base ? `"${specifier}" from ` : "") + url.fileURLToPath(base || specifier),
+      (base ? `"${specifier}" from ` : "") + require$$7.fileURLToPath(base || specifier),
       exception.message
     );
   }
@@ -26473,23 +26471,23 @@ function getPackageConfig(path9, specifier, base) {
   return packageConfig;
 }
 function getPackageScopeConfig(resolved) {
-  let packageJsonUrl = new url.URL("package.json", resolved);
+  let packageJsonUrl = new require$$7.URL("package.json", resolved);
   while (true) {
     const packageJsonPath2 = packageJsonUrl.pathname;
     if (packageJsonPath2.endsWith("node_modules/package.json"))
       break;
     const packageConfig2 = getPackageConfig(
-      url.fileURLToPath(packageJsonUrl),
+      require$$7.fileURLToPath(packageJsonUrl),
       resolved
     );
     if (packageConfig2.exists)
       return packageConfig2;
     const lastPackageJsonUrl = packageJsonUrl;
-    packageJsonUrl = new url.URL("../package.json", packageJsonUrl);
+    packageJsonUrl = new require$$7.URL("../package.json", packageJsonUrl);
     if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname)
       break;
   }
-  const packageJsonPath = url.fileURLToPath(packageJsonUrl);
+  const packageJsonPath = require$$7.fileURLToPath(packageJsonUrl);
   const packageConfig = {
     pjsonPath: packageJsonPath,
     exists: false,
@@ -26558,10 +26556,10 @@ function extname(url) {
   }
   return "";
 }
-function getFileProtocolModuleFormat(url$1, _context, ignoreErrors) {
-  const ext = extname(url$1);
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+  const ext = extname(url);
   if (ext === ".js") {
-    return getPackageType(url$1) === "module" ? "module" : "commonjs";
+    return getPackageType(url) === "module" ? "module" : "commonjs";
   }
   const format3 = extensionFormatMap[ext];
   if (format3)
@@ -26569,7 +26567,7 @@ function getFileProtocolModuleFormat(url$1, _context, ignoreErrors) {
   if (ignoreErrors) {
     return void 0;
   }
-  const filepath = url.fileURLToPath(url$1);
+  const filepath = require$$7.fileURLToPath(url);
   throw new ERR_UNKNOWN_FILE_EXTENSION(ext, filepath);
 }
 function getHttpProtocolModuleFormat() {
@@ -26628,21 +26626,21 @@ var encodedSepRegEx = /%2f|%5c/i;
 var emittedPackageWarnings = /* @__PURE__ */ new Set();
 var doubleSlashRegEx = /[/\\]{2}/;
 function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
-  const pjsonPath = url.fileURLToPath(packageJsonUrl);
+  const pjsonPath = require$$7.fileURLToPath(packageJsonUrl);
   const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
   process4__default.emitWarning(
-    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${url.fileURLToPath(base)}` : ""}.`,
+    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${require$$7.fileURLToPath(base)}` : ""}.`,
     "DeprecationWarning",
     "DEP0166"
   );
 }
-function emitLegacyIndexDeprecation(url$1, packageJsonUrl, base, main) {
-  const format3 = defaultGetFormatWithoutErrors(url$1, { parentURL: base.href });
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  const format3 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
   if (format3 !== "module")
     return;
-  const path9 = url.fileURLToPath(url$1.href);
-  const pkgPath = url.fileURLToPath(new url.URL(".", packageJsonUrl));
-  const basePath = url.fileURLToPath(base);
+  const path9 = require$$7.fileURLToPath(url.href);
+  const pkgPath = require$$7.fileURLToPath(new require$$7.URL(".", packageJsonUrl));
+  const basePath = require$$7.fileURLToPath(base);
   if (main)
     process4__default.emitWarning(
       `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, excluding the full filename and extension to the resolved file at "${path9.slice(
@@ -26677,7 +26675,7 @@ function fileExists(url) {
 function legacyMainResolve(packageJsonUrl, packageConfig, base) {
   let guess;
   if (packageConfig.main !== void 0) {
-    guess = new url.URL(packageConfig.main, packageJsonUrl);
+    guess = new require$$7.URL(packageConfig.main, packageJsonUrl);
     if (fileExists(guess))
       return guess;
     const tries2 = [
@@ -26690,7 +26688,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
     ];
     let i2 = -1;
     while (++i2 < tries2.length) {
-      guess = new url.URL(tries2[i2], packageJsonUrl);
+      guess = new require$$7.URL(tries2[i2], packageJsonUrl);
       if (fileExists(guess))
         break;
       guess = void 0;
@@ -26708,7 +26706,7 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
   const tries = ["./index.js", "./index.json", "./index.node"];
   let i = -1;
   while (++i < tries.length) {
-    guess = new url.URL(tries[i], packageJsonUrl);
+    guess = new require$$7.URL(tries[i], packageJsonUrl);
     if (fileExists(guess))
       break;
     guess = void 0;
@@ -26718,8 +26716,8 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) {
     return guess;
   }
   throw new ERR_MODULE_NOT_FOUND(
-    url.fileURLToPath(new url.URL(".", packageJsonUrl)),
-    url.fileURLToPath(base)
+    require$$7.fileURLToPath(new require$$7.URL(".", packageJsonUrl)),
+    require$$7.fileURLToPath(base)
   );
 }
 function finalizeResolution(resolved, base, preserveSymlinks) {
@@ -26727,28 +26725,28 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
     throw new ERR_INVALID_MODULE_SPECIFIER(
       resolved.pathname,
       'must not include encoded "/" or "\\" characters',
-      url.fileURLToPath(base)
+      require$$7.fileURLToPath(base)
     );
-  const filePath = url.fileURLToPath(resolved);
+  const filePath = require$$7.fileURLToPath(resolved);
   const stats = tryStatSync(
     filePath.endsWith("/") ? filePath.slice(-1) : filePath
   );
   if (stats.isDirectory()) {
-    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, url.fileURLToPath(base));
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, require$$7.fileURLToPath(base));
     error.url = String(resolved);
     throw error;
   }
   if (!stats.isFile()) {
     throw new ERR_MODULE_NOT_FOUND(
       filePath || resolved.pathname,
-      base && url.fileURLToPath(base),
+      base && require$$7.fileURLToPath(base),
       "module"
     );
   }
   if (!preserveSymlinks) {
     const real = fs$1.realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = url.pathToFileURL(real + (filePath.endsWith(path6__default.sep) ? "/" : ""));
+    resolved = require$$7.pathToFileURL(real + (filePath.endsWith(require$$0__default.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -26757,33 +26755,33 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
 function importNotDefined(specifier, packageJsonUrl, base) {
   return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
     specifier,
-    packageJsonUrl && url.fileURLToPath(new url.URL(".", packageJsonUrl)),
-    url.fileURLToPath(base)
+    packageJsonUrl && require$$7.fileURLToPath(new require$$7.URL(".", packageJsonUrl)),
+    require$$7.fileURLToPath(base)
   );
 }
 function exportsNotFound(subpath, packageJsonUrl, base) {
   return new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    url.fileURLToPath(new url.URL(".", packageJsonUrl)),
+    require$$7.fileURLToPath(new require$$7.URL(".", packageJsonUrl)),
     subpath,
-    base && url.fileURLToPath(base)
+    base && require$$7.fileURLToPath(base)
   );
 }
 function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
-  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${url.fileURLToPath(packageJsonUrl)}`;
+  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${require$$7.fileURLToPath(packageJsonUrl)}`;
   throw new ERR_INVALID_MODULE_SPECIFIER(
     request,
     reason,
-    base && url.fileURLToPath(base)
+    base && require$$7.fileURLToPath(base)
   );
 }
 function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
   target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
   return new ERR_INVALID_PACKAGE_TARGET(
-    url.fileURLToPath(new url.URL(".", packageJsonUrl)),
+    require$$7.fileURLToPath(new require$$7.URL(".", packageJsonUrl)),
     subpath,
     target,
     internal,
-    base && url.fileURLToPath(base)
+    base && require$$7.fileURLToPath(base)
   );
 }
 function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
@@ -26793,7 +26791,7 @@ function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base
     if (internal && !target.startsWith("../") && !target.startsWith("/")) {
       let isURL2 = false;
       try {
-        new url.URL(target);
+        new require$$7.URL(target);
         isURL2 = true;
       } catch {
       }
@@ -26831,9 +26829,9 @@ function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base
       throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
     }
   }
-  const resolved = new url.URL(target, packageJsonUrl);
+  const resolved = new require$$7.URL(target, packageJsonUrl);
   const resolvedPath = resolved.pathname;
-  const packagePath = new url.URL(".", packageJsonUrl).pathname;
+  const packagePath = new require$$7.URL(".", packageJsonUrl).pathname;
   if (!resolvedPath.startsWith(packagePath))
     throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
   if (subpath === "")
@@ -26862,7 +26860,7 @@ function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base
     }
   }
   if (pattern) {
-    return new url.URL(
+    return new require$$7.URL(
       RegExpPrototypeSymbolReplace.call(
         patternRegEx,
         resolved.href,
@@ -26870,7 +26868,7 @@ function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base
       )
     );
   }
-  return new url.URL(subpath, resolved);
+  return new require$$7.URL(subpath, resolved);
 }
 function isArrayIndex(key) {
   const keyNumber = Number(key);
@@ -26943,7 +26941,7 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b
       const key = keys[i];
       if (isArrayIndex(key)) {
         throw new ERR_INVALID_PACKAGE_CONFIG2(
-          url.fileURLToPath(packageJsonUrl),
+          require$$7.fileURLToPath(packageJsonUrl),
           base,
           '"exports" cannot contain numeric property keys.'
         );
@@ -27002,7 +27000,7 @@ function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
       isConditionalSugar = curIsConditionalSugar;
     } else if (isConditionalSugar !== curIsConditionalSugar) {
       throw new ERR_INVALID_PACKAGE_CONFIG2(
-        url.fileURLToPath(packageJsonUrl),
+        require$$7.fileURLToPath(packageJsonUrl),
         base,
         `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`
       );
@@ -27011,12 +27009,12 @@ function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
   return isConditionalSugar;
 }
 function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
-  const pjsonPath = url.fileURLToPath(pjsonUrl);
+  const pjsonPath = require$$7.fileURLToPath(pjsonUrl);
   if (emittedPackageWarnings.has(pjsonPath + "|" + match))
     return;
   emittedPackageWarnings.add(pjsonPath + "|" + match);
   process4__default.emitWarning(
-    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${url.fileURLToPath(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
+    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${require$$7.fileURLToPath(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
     "DeprecationWarning",
     "DEP0155"
   );
@@ -27114,12 +27112,12 @@ function patternKeyCompare(a, b) {
 function packageImportsResolve(name, base, conditions) {
   if (name === "#" || name.startsWith("#/") || name.endsWith("/")) {
     const reason = "is not a valid internal imports specifier name";
-    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, url.fileURLToPath(base));
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, require$$7.fileURLToPath(base));
   }
   let packageJsonUrl;
   const packageConfig = getPackageScopeConfig(base);
   if (packageConfig.exists) {
-    packageJsonUrl = url.pathToFileURL(packageConfig.pjsonPath);
+    packageJsonUrl = require$$7.pathToFileURL(packageConfig.pjsonPath);
     const imports = packageConfig.imports;
     if (imports) {
       if (own2.call(imports, name) && !name.includes("*")) {
@@ -27198,15 +27196,15 @@ function parsePackageName(specifier, base) {
     throw new ERR_INVALID_MODULE_SPECIFIER(
       specifier,
       "is not a valid package name",
-      url.fileURLToPath(base)
+      require$$7.fileURLToPath(base)
     );
   }
   const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
   return { packageName, packageSubpath, isScoped };
 }
 function packageResolve(specifier, base, conditions) {
-  if (module$1.builtinModules.includes(specifier)) {
-    return new url.URL("node:" + specifier);
+  if (require$$2.builtinModules.includes(specifier)) {
+    return new require$$7.URL("node:" + specifier);
   }
   const { packageName, packageSubpath, isScoped } = parsePackageName(
     specifier,
@@ -27214,7 +27212,7 @@ function packageResolve(specifier, base, conditions) {
   );
   const packageConfig = getPackageScopeConfig(base);
   if (packageConfig.exists) {
-    const packageJsonUrl2 = url.pathToFileURL(packageConfig.pjsonPath);
+    const packageJsonUrl2 = require$$7.pathToFileURL(packageConfig.pjsonPath);
     if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
       return packageExportsResolve(
         packageJsonUrl2,
@@ -27225,21 +27223,21 @@ function packageResolve(specifier, base, conditions) {
       );
     }
   }
-  let packageJsonUrl = new url.URL(
+  let packageJsonUrl = new require$$7.URL(
     "./node_modules/" + packageName + "/package.json",
     base
   );
-  let packageJsonPath = url.fileURLToPath(packageJsonUrl);
+  let packageJsonPath = require$$7.fileURLToPath(packageJsonUrl);
   let lastPath;
   do {
     const stat = tryStatSync(packageJsonPath.slice(0, -13));
     if (!stat.isDirectory()) {
       lastPath = packageJsonPath;
-      packageJsonUrl = new url.URL(
+      packageJsonUrl = new require$$7.URL(
         (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
         packageJsonUrl
       );
-      packageJsonPath = url.fileURLToPath(packageJsonUrl);
+      packageJsonPath = require$$7.fileURLToPath(packageJsonUrl);
       continue;
     }
     const packageConfig2 = getPackageConfig(packageJsonPath, specifier, base);
@@ -27255,9 +27253,9 @@ function packageResolve(specifier, base, conditions) {
     if (packageSubpath === ".") {
       return legacyMainResolve(packageJsonUrl, packageConfig2, base);
     }
-    return new url.URL(packageSubpath, packageJsonUrl);
+    return new require$$7.URL(packageSubpath, packageJsonUrl);
   } while (packageJsonPath.length !== lastPath.length);
-  throw new ERR_MODULE_NOT_FOUND(packageName, url.fileURLToPath(base));
+  throw new ERR_MODULE_NOT_FOUND(packageName, require$$7.fileURLToPath(base));
 }
 function isRelativeSpecifier(specifier) {
   if (specifier[0] === ".") {
@@ -27281,12 +27279,12 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
   const isRemote = protocol === "http:" || protocol === "https:";
   let resolved;
   if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    resolved = new url.URL(specifier, base);
+    resolved = new require$$7.URL(specifier, base);
   } else if (!isRemote && specifier[0] === "#") {
     resolved = packageImportsResolve(specifier, base, conditions);
   } else {
     try {
-      resolved = new url.URL(specifier);
+      resolved = new require$$7.URL(specifier);
     } catch {
       if (!isRemote) {
         resolved = packageResolve(specifier, base, conditions);
@@ -27314,7 +27312,7 @@ function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
         }
         return { url: (parsed == null ? void 0 : parsed.href) || "" };
       }
-      if (module$1.builtinModules.includes(specifier)) {
+      if (require$$2.builtinModules.includes(specifier)) {
         throw new ERR_NETWORK_IMPORT_DISALLOWED(
           specifier,
           parsedParentURL,
@@ -27370,13 +27368,13 @@ function defaultResolve(specifier, context = {}) {
   let parsedParentURL;
   if (parentURL) {
     try {
-      parsedParentURL = new url.URL(parentURL);
+      parsedParentURL = new require$$7.URL(parentURL);
     } catch {
     }
   }
   let parsed;
   try {
-    parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier) ? new url.URL(specifier, parsedParentURL) : new url.URL(specifier);
+    parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier) ? new require$$7.URL(specifier, parsedParentURL) : new require$$7.URL(specifier);
     const protocol = parsed.protocol;
     if (protocol === "data:" || experimentalNetworkImports && (protocol === "https:" || protocol === "http:")) {
       return { url: parsed.href, format: null };
@@ -27394,13 +27392,13 @@ function defaultResolve(specifier, context = {}) {
     return { url: specifier };
   throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports);
   const conditions = getConditionsSet(context.conditions);
-  const url$1 = moduleResolve(specifier, new url.URL(parentURL), conditions, false);
-  throwIfUnsupportedURLProtocol(url$1);
+  const url = moduleResolve(specifier, new require$$7.URL(parentURL), conditions, false);
+  throwIfUnsupportedURLProtocol(url);
   return {
     // Do NOT cast `url` to a string: that will work even when there are real
     // problems, silencing them
-    url: url$1.href,
-    format: defaultGetFormatWithoutErrors(url$1, { parentURL })
+    url: url.href,
+    format: defaultGetFormatWithoutErrors(url, { parentURL })
   };
 }
 
@@ -27427,8 +27425,8 @@ function resolve(specifier, parent) {
 
 // src/utils/import-from-file.js
 function importFromFile(specifier, parent) {
-  const url$1 = resolve(specifier, url.pathToFileURL(parent).href);
-  return import(url$1);
+  const url = resolve(specifier, require$$7.pathToFileURL(parent).href);
+  return import(url);
 }
 var import_from_file_default = importFromFile;
 
@@ -27547,7 +27545,7 @@ async function resolveConfig(filePath, options8) {
   };
   if (Array.isArray(merged.plugins)) {
     merged.plugins = merged.plugins.map(
-      (value) => typeof value === "string" && value.startsWith(".") ? path6__default.resolve(path6__default.dirname(result.filepath), value) : value
+      (value) => typeof value === "string" && value.startsWith(".") ? require$$0__default.resolve(require$$0__default.dirname(result.filepath), value) : value
     );
   }
   return merged;
@@ -27561,7 +27559,7 @@ function mergeOverrides(configResult, filePath) {
   const { config, filepath: configPath } = configResult || {};
   const { overrides, ...options8 } = config || {};
   if (filePath && overrides) {
-    const relativeFilePath = path6__default.relative(path6__default.dirname(configPath), filePath);
+    const relativeFilePath = require$$0__default.relative(require$$0__default.dirname(configPath), filePath);
     for (const override of overrides) {
       if (pathMatchesGlobs(
         relativeFilePath,
@@ -27607,7 +27605,7 @@ var read_file_default = readFile;
 
 // src/utils/ignore.js
 var createIgnore = import_ignore.default.default;
-var slash = path6__default.sep === "\\" ? (filepath) => string_replace_all_default(
+var slash = require$$0__default.sep === "\\" ? (filepath) => string_replace_all_default(
   /* isOptionalObject*/
   false,
   filepath,
@@ -27629,8 +27627,8 @@ async function createSingleIsIgnoredFunction(ignoreFilePath, withNodeModules) {
     allowRelativePaths: true
   }).add(content);
   return (filepath) => {
-    filepath = path6__default.resolve(filepath);
-    const relativePath = ignoreFilePath ? path6__default.relative(path6__default.dirname(ignoreFilePath), filepath) : path6__default.relative(process.cwd(), filepath);
+    filepath = require$$0__default.resolve(filepath);
+    const relativePath = ignoreFilePath ? require$$0__default.relative(require$$0__default.dirname(ignoreFilePath), filepath) : require$$0__default.relative(process.cwd(), filepath);
     return ignore.ignores(slash(relativePath));
   };
 }
@@ -27680,7 +27678,7 @@ async function getParser(filePath, options8) {
 }
 var get_file_info_default = getFileInfo;
 function importFromDirectory(specifier, directory) {
-  return import_from_file_default(specifier, path6__default.join(directory, "noop.js"));
+  return import_from_file_default(specifier, require$$0__default.join(directory, "noop.js"));
 }
 var import_from_directory_default = importFromDirectory;
 
@@ -27695,7 +27693,7 @@ var loadPluginFromDirectory = mem(
 );
 var importPlugin = mem(async (name) => {
   try {
-    return await import(url.pathToFileURL(path6__default.resolve(name)).href);
+    return await import(require$$7.pathToFileURL(require$$0__default.resolve(name)).href);
   } catch {
     return import_from_directory_default(name, process.cwd());
   }
@@ -29042,825 +29040,4 @@ var debugApis = {
   printDocToString: withPlugins(printDocToString2)
 };
 
-function defineClientGeneratorPlugin(plugin) {
-  return plugin;
-}
-
-let createdModels = [];
-const typescriptClientGenerator = defineClientGeneratorPlugin(
-  (options) => ({
-    generator: async (def) => {
-      if (!options.name) {
-        throw new Error("Name is requires");
-      }
-      if (!options.outputFile) {
-        throw new Error("No output file specified");
-      }
-      const result = await createTypescriptClient(def, options.name);
-      fs$1.writeFileSync(options.outputFile, result);
-    },
-    options
-  })
-);
-async function createTypescriptClient(def, prefix = "Client") {
-  createdModels = [];
-  const services = index.unflattenObject(def.procedures);
-  const serviceParts = [];
-  const modelParts = [];
-  Object.keys(services).forEach((key) => {
-    const serviceName = index.pascalCase(`${prefix}_${key}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key,
-      content: tsServiceFromServiceDefinition(serviceName, services[key])
-    });
-  });
-  Object.keys(def.models).forEach((key) => {
-    const modelName = index.pascalCase(`${key}`);
-    if (!createdModels.includes(modelName)) {
-      modelParts.push(tsModelFromDefinition(modelName, def.models[key]));
-      createdModels.push(modelName);
-    }
-  });
-  return format2(
-    `/* eslint-disable */
-    import { arriRequest, ArriRequestError } from 'arri-client';
-    
-    export class ${prefix} {
-        ${serviceParts.map((service) => `${service.key}: ${service.name}`).join("\n")}
-        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
-            ${serviceParts.map(
-      (service) => `this.${service.key} = new ${service.name}(opts);`
-    ).join("\n")}
-        }
-    }
-
-    ${serviceParts.map((service) => service.content).join("\n")}
-    ${modelParts.join("\n")}`,
-    {
-      parser: "typescript"
-    }
-  );
-}
-function tsServiceFromServiceDefinition(name, def) {
-  const rpcParts = [];
-  const subServiceParts = [];
-  Object.keys(def).forEach((key) => {
-    const val = def[key];
-    if (index.isProcedureDefinition(val)) {
-      rpcParts.push(tsRpcFromProcedureDefinition(key, val));
-      return;
-    }
-    const subServiceName = index.pascalCase(
-      `${name.split("Service").join("")}_${key}_service`
-    );
-    subServiceParts.push({
-      name: subServiceName,
-      key,
-      content: tsServiceFromServiceDefinition(subServiceName, val)
-    });
-  });
-  return `export class ${name} {
-        baseUrl: string;
-        headers: Record<string, string>;
-        ${subServiceParts.map((service) => `${service.key}: ${service.name};`).join("\n")}
-        constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
-            this.baseUrl = opts.baseUrl ?? "";
-            this.headers = opts.headers ?? {};
-            ${subServiceParts.map(
-    (service) => `this.${service.key} = new ${service.name}(opts);`
-  ).join("\n")}
-        }
-        ${rpcParts.join("\n")}
-    }
-    ${subServiceParts.map((service) => service.content).join("\n")}`;
-}
-function tsRpcFromProcedureDefinition(name, def) {
-  let paramStr = "";
-  let responseName = "";
-  if (def.params) {
-    paramStr = `params: ${def.params}`;
-  }
-  if (def.response) {
-    responseName = def.response;
-  }
-  return `async ${name}(${paramStr}) {
-        return arriRequest<${responseName || "undefined"}>({
-            url: \`\${this.baseUrl}${def.path}\`,
-            method: '${def.method}',
-            ${paramStr.length ? `params,` : ""}
-            headers: this.headers,
-        });
-    }`;
-}
-function tsModelFromDefinition(name, def) {
-  const fieldParts = [];
-  const subModelParts = [];
-  Object.keys(def.properties ?? {}).forEach((key) => {
-    const isOptional = !def.required?.includes(key);
-    const prop = def.properties?.[key];
-    const keyPart = isOptional ? `${key}?` : key;
-    if (index.isJsonSchemaScalarType(prop)) {
-      fieldParts.push(
-        tsInterfaceScalarField(key, prop, isOptional) ?? ""
-      );
-      return;
-    }
-    if (index.isJsonSchemaNullType(prop)) {
-      switch (prop.type) {
-        case "null":
-          fieldParts.push(`${keyPart}: null;`);
-          break;
-        case "undefined":
-          fieldParts.push(`${keyPart}: undefined`);
-          break;
-      }
-      return;
-    }
-    if (index.isJsonSchemaObject(prop)) {
-      const subModelName = prop.$id ?? index.pascalCase(`${name}_${key}`);
-      if (!createdModels.includes(subModelName)) {
-        const content = tsModelFromDefinition(
-          subModelName,
-          prop
-        );
-        subModelParts.push(content);
-      }
-      fieldParts.push(`${keyPart}: ${subModelName};`);
-      return;
-    }
-    if (index.isJsonSchemaEnum(prop)) {
-      const vals = prop.anyOf.map(
-        (opt) => opt.type === "string" ? `'${opt.const}'` : `${opt.const}`
-      );
-      fieldParts.push(`${keyPart}: ${vals.join(" | ")};`);
-      return;
-    }
-    if (index.isJsonSchemaArray(prop)) {
-      if (index.isJsonSchemaScalarType(prop.items)) {
-        const part = tsInterfaceScalarField(
-          key,
-          prop.items,
-          isOptional
-        ).replace(";", "[];");
-        fieldParts.push(part);
-        return;
-      }
-      if (index.isJsonSchemaNullType(prop.items)) {
-        if (prop.items.type === "null") {
-          fieldParts.push(`${keyPart}: null[]`);
-          return;
-        }
-        fieldParts.push(`${keyPart}: undefined[]`);
-        return;
-      }
-      if (index.isJsonSchemaObject(prop.items)) {
-        const subModelName = prop.items.$id ?? index.pascalCase(`${name}_${key}_item`);
-        if (!createdModels.includes(subModelName)) {
-          subModelParts.push(
-            tsModelFromDefinition(subModelName, prop.items)
-          );
-        }
-        fieldParts.push(`${keyPart}: ${subModelName}[];`);
-      }
-    }
-  });
-  return `export interface ${name} {
-        ${fieldParts.join("\n")}
-    }
-    ${subModelParts.join("\n")}`;
-}
-function tsInterfaceScalarField(key, prop, isOptional = false) {
-  const keyPart = isOptional ? `${key}?` : key;
-  switch (prop.type) {
-    case "string":
-      return `${keyPart}: string;`;
-    case "bigint":
-      return `${keyPart}: bigint;`;
-    case "Date":
-      return `${keyPart}: Date;`;
-    case "boolean":
-      return `${keyPart}: boolean;`;
-    case "integer":
-      return `/**
-                    * must be an integer
-                    */
-                    ${keyPart}: number;`;
-    case "number":
-      return `${keyPart}: number;`;
-  }
-}
-
-const dartClientGenerator = defineClientGeneratorPlugin(
-  (options) => {
-    return {
-      generator: async (def) => {
-        if (!options.clientName) {
-          throw new Error(
-            'Missing "clientName" cannot generate dart client'
-          );
-        }
-        if (!options.outputFile) {
-          throw new Error(
-            'Missing "outputFile" cannot generate dart client'
-          );
-        }
-        const result = createDartClient(def, options.clientName);
-        fs$1.writeFileSync(options.outputFile, result);
-        child_process.execSync(`dart format ${options.outputFile}`);
-      },
-      options
-    };
-  }
-);
-const generatedModels = [];
-function createDartClient(appDef, prefix = "Client") {
-  const { models, procedures } = appDef;
-  const serviceParts = [];
-  const services = index.unflattenObject(procedures);
-  Object.keys(services).forEach((k) => {
-    const service = services[k];
-    const serviceName = index.pascalCase(`$_${prefix}_${k}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key: k,
-      content: dartServiceFromServiceDefinition(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        serviceName,
-        service,
-        prefix
-      )
-    });
-  });
-  const endpoints = {};
-  Object.keys(procedures).forEach((key) => {
-    const rpc = procedures[key];
-    endpoints[rpc.path] = rpc.method;
-  });
-  const modelParts = [];
-  Object.keys(models).forEach((key) => {
-    const model = models[key];
-    const typeName = `${prefix}${index.pascalCase(key)}`;
-    const objModel = model;
-    if (!generatedModels.includes(typeName)) {
-      modelParts.push(
-        dartModelFromJsonSchema(
-          `${prefix}${index.pascalCase(key)}`,
-          objModel
-        )
-      );
-      generatedModels.push(typeName);
-    }
-  });
-  return `// This code was autogenerated by arri. Do not modify directly.
-import "dart:convert";
-import "package:http/http.dart" as http;
-import "package:arri_client/arri_client.dart";
-
-class ${prefix} {
-  final String baseUrl;
-  final Map<String, String> headers;
-  const ${prefix}({
-    this.baseUrl = "",
-    this.headers = const {},
-  });
-  ${prefix} withHeaders(Map<String, String> headers) {
-    return ${prefix}(
-      baseUrl: baseUrl,
-      headers: headers,
-    );
-  }
-  ${serviceParts.map(
-    (service) => `${service.name} get ${service.key} {
-    return ${service.name}(
-      baseUrl: baseUrl, headers: headers,
-    );
-  }`
-  ).join("\n  ")}
-  Future<http.Response> rawRequest(
-    ${prefix}Endpoints endpoint, {
-    Map<String, String>? query,
-    dynamic body,
-    Map<String, String>? headers,
-    Encoding? encoding,
-  }) async {
-    return arriRequest(
-      "$baseUrl\${endpoint.path}",
-      method: endpoint.method,
-      headers: headers ?? this.headers,
-      body: body,
-      query: query,
-      encoding: encoding,
-    );
-  }
-}
-${serviceParts.map((item) => item.content).join("\n")}
-${modelParts.join("\n")}
-
-enum ${prefix}Endpoints implements Comparable<${prefix}Endpoints>, ArriEndpoint {
-  ${Object.keys(endpoints).map(
-    (key) => `${index.camelCase(key.split("/").join("_"))}(
-        path: "${key}",
-        method: HttpMethod.${endpoints[key]},
-      )`
-  ).join(",\n  ")};
-
-  const ${prefix}Endpoints({
-    required this.path, required this.method,
-  });
-  @override
-  final String path;
-  @override
-  final HttpMethod method;
-
-  @override
-  compareTo(BackendEndpoints other) => name.compareTo(other.name);
-}`;
-}
-function dartServiceFromServiceDefinition(name, def, prefix = "") {
-  const rpcParts = [];
-  const subServiceParts = [];
-  const serviceName = `${name}`;
-  Object.keys(def).forEach((key) => {
-    const item = def[key];
-    if (index.isProcedureDefinition(item)) {
-      let returnType = `Future<String>`;
-      let returnTypeName = "String";
-      if (item.response) {
-        returnType = `Future<${prefix}${item.response}>`;
-        returnTypeName = `${prefix}${item.response}`;
-      } else {
-        returnType = "Future<void>";
-      }
-      let paramsInput = "";
-      if (item.params) {
-        paramsInput = `${prefix}${item.params} params`;
-      }
-      let responseParser = "(body) => body;";
-      switch (returnType) {
-        case "Future<String>":
-          break;
-        case "Future<int>":
-          responseParser = `(body) => Int.parse(body)`;
-          break;
-        case "Future<double>":
-          responseParser = `(body) => Double.parse(body)`;
-          break;
-        case "Future<void>":
-          responseParser = `(body) {}`;
-          break;
-        case "Future<bool>":
-          responseParser = `(body) {
-                        switch(body) {
-                            case "true":
-                            case "1":
-                                return true;
-                            case "false":
-                            case "0":
-                            default:
-                                return false;
-                        }
-                    }`;
-          break;
-        default:
-          responseParser = `(body) => ${returnTypeName}.fromJson(json.decode(body))`;
-          break;
-      }
-      rpcParts.push(`${returnType} ${key}(${paramsInput}) {
-    return parsedArriRequest(
-      "$baseUrl${item.path}",
-      method: HttpMethod.${item.method},
-      headers: headers,
-      params: ${paramsInput.length ? `params.toJson()` : "null"},
-      parser: ${responseParser},
-    );
-  }`);
-      return;
-    }
-    const subServiceName = index.pascalCase(`${name}_${key}_Service`);
-    const subService = dartServiceFromServiceDefinition(
-      index.pascalCase(`${name}_${key}_Service`),
-      item,
-      prefix
-    );
-    subServiceParts.push({
-      name: subServiceName,
-      key,
-      content: subService
-    });
-  });
-  return `class ${serviceName} {
-  final String baseUrl;
-  final Map<String, String> headers;
-  const ${serviceName}({
-    this.baseUrl = "",
-    this.headers = const {},
-  });
-  ${subServiceParts.map(
-    (sub) => `${sub.name} get ${sub.key} {
-    return ${sub.name}(
-        baseUrl: baseUrl,
-        headers: headers,
-    );
-  }`
-  ).join("\n")}
-  ${rpcParts.join("\n  ")}
-}
-${subServiceParts.map((sub) => sub.content).join("\n")}
-`;
-}
-function dartModelFromJsonSchema(name, schema) {
-  const fields = [];
-  const subModelParts = [];
-  Object.entries(schema.properties ?? {}).forEach(([key, val]) => {
-    if (typeof val !== "object") {
-      return;
-    }
-    const [dartType, subTypes] = dartPropertyTypeFromSchema(
-      name,
-      key,
-      schema
-    );
-    if (subTypes?.length) {
-      for (const sub of subTypes) {
-        subModelParts.push(sub);
-      }
-    }
-    fields.push({ type: dartType, name: key });
-    if (!isDartType(dartType) && "type" in val && val.type === "object") {
-      subModelParts.push(
-        dartModelFromJsonSchema(dartType.replace("?", ""), val)
-      );
-    }
-  });
-  return `class ${name} {
-  ${fields.map((field) => `final ${field.type} ${field.name};`).join("\n  ")}
-  const ${name}({
-    ${fields.map(
-    (field) => field.type.includes("?") ? `this.${field.name},` : `required this.${field.name},`
-  ).join("\n    ")}
-  });
-  factory ${name}.fromJson(Map<String, dynamic> json) {
-    return ${name}(
-      ${fields.map((field) => `${dartParsedJsonField(field.name, field.type)},`).join("\n      ")}
-    );
-  }
-  Map<String, dynamic> toJson() {
-    return {
-      ${fields.map((field) => {
-    const isNullable = field.type.endsWith("?");
-    const typeName = field.type.replace("?", "");
-    if (isDartTypeWithNullables(field.type)) {
-      const transformer = transformers[typeName];
-      return transformer.toJsonBody(field.name, isNullable);
-    }
-    if (field.type.includes("List<")) {
-      return classListTransformer(typeName).toJsonBody(
-        field.name,
-        isNullable
-      );
-    }
-    return classTransformer(typeName, isNullable).toJsonBody(
-      field.name,
-      isNullable
-    );
-  }).join(",\n      ")},
-    };
-  }
-  ${name} copyWith({
-    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
-  }) {
-    return ${name}(
-      ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
-    );
-  }
-}
-
-${subModelParts.join("\n")}`;
-}
-function dartPropertyTypeFromSchema(objectName, propertyName, schema) {
-  const prop = schema.properties?.[propertyName];
-  const isOptional = !schema.required?.includes(propertyName);
-  let finalType = "";
-  const subTypes = [];
-  if (index.isJsonSchemaEnum(prop)) {
-    const enumName = index.pascalCase(`${objectName}_${propertyName}`);
-    finalType = isOptional ? `${enumName}?` : enumName;
-    const options = [];
-    for (const opt of prop.anyOf) {
-      if (opt.type === "string") {
-        options.push({
-          name: opt.const.toString(),
-          type: "String",
-          value: opt.const
-        });
-      }
-      if (opt.type === "number" || opt.type === "integer") {
-        options.push({
-          name: index.camelCase(
-            `num_${opt.const}`.split(".").join("Point")
-          ),
-          type: opt.type === "number" ? "double" : "int",
-          value: opt.const
-        });
-      }
-    }
-    subTypes.push(`enum ${enumName} implements Comparable<${enumName}> {
-  ${options.map(
-      (opt) => `${opt.name}(${opt.type === "String" ? `"${opt.value}"` : opt.value})`
-    ).join(",\n  ")};
-  const ${enumName}(this.value);
-  final dynamic value;
-
-  @override
-  compareTo(${enumName} other) => name.compareTo(other.name);
-
-  factory ${enumName}.fromJson(dynamic input) {
-    for(final val in values) {
-      if(val.value == input) {
-        return val;
-      }
-    }
-    return ${options[0].name};
-  }
-
-  dynamic toJson() {
-    return value;
-  }
-}`);
-    return [finalType, subTypes];
-  }
-  if (index.isJsonSchemaNullType(prop)) {
-    finalType = "null";
-    return [finalType, subTypes];
-  }
-  if (index.isJsonSchemaScalarType(prop)) {
-    switch (prop.type) {
-      case "string":
-        finalType = isOptional ? "String?" : "String";
-        break;
-      case "integer":
-        finalType = isOptional ? "int?" : "int";
-        break;
-      case "number":
-        finalType = isOptional ? "double?" : "double";
-        break;
-      case "Date":
-        finalType = isOptional ? "DateTime?" : "DateTime";
-        break;
-      case "boolean":
-        finalType = isOptional ? "bool?" : "bool";
-        break;
-    }
-  }
-  if (index.isJsonSchemaObject(prop)) {
-    const joinedPropName = index.pascalCase(
-      `${objectName}_${propertyName}`
-    );
-    finalType = isOptional ? `${joinedPropName}?` : joinedPropName;
-  }
-  if (index.isJsonSchemaArray(prop)) {
-    const item = prop.items;
-    const type = item.type;
-    if (typeof type !== "string") {
-      throw new Error(
-        "Union types are not supported in arrays at this time"
-      );
-    }
-    switch (type) {
-      case "string":
-        finalType = isOptional ? "List<String>?" : "List<String>";
-        break;
-      case "integer":
-        finalType = isOptional ? "List<int>?" : "List<int>";
-        break;
-      case "number":
-        finalType = isOptional ? "List<double>?" : "List<double>";
-        break;
-      case "null":
-        finalType = isOptional ? "List<null>?" : "List<null>";
-        break;
-      case "boolean":
-        finalType = isOptional ? "List<bool>?" : "List<bool>";
-        break;
-      case "Date":
-        finalType = isOptional ? "List<DateTime>?" : "List<DateTime>";
-        break;
-      case "object": {
-        const subTypeName = item.$id ?? index.pascalCase(`${objectName}_${propertyName}_item`);
-        const model = dartModelFromJsonSchema(subTypeName, item);
-        if (!generatedModels.includes(subTypeName)) {
-          subTypes.push(model);
-          generatedModels.push(subTypeName);
-        }
-        finalType = isOptional ? `List<${subTypeName}>?` : `List<${subTypeName}>`;
-        break;
-      }
-    }
-  }
-  return [finalType, subTypes.length ? subTypes : void 0];
-}
-function dartParsedJsonField(fieldName, dartType) {
-  if (isDartTypeWithNullables(dartType)) {
-    switch (dartType) {
-      case "String":
-        return transformers.String.fromJsonBody(fieldName, '""');
-      case "String?":
-        return transformers.String.fromJsonBody(fieldName, "null");
-      case "bool":
-        return transformers.bool.fromJsonBody(fieldName, "false");
-      case "double":
-        return transformers.double.fromJsonBody(fieldName, "0.0");
-      case "int":
-        return transformers.int.fromJsonBody(fieldName, "0");
-      case "null":
-        return transformers.null.fromJsonBody(fieldName, "");
-      case "DateTime":
-        return transformers.DateTime.fromJsonBody(
-          fieldName,
-          "DateTime(0)"
-        );
-      case "DateTime?":
-        return transformers.DateTime.fromJsonBody(fieldName, "null");
-      case "List<String>":
-      case "List<bool>":
-      case "List<double>":
-      case "List<int>":
-      case "List<null>":
-        return defaultListFromJsonBody(
-          fieldName,
-          dartType.replace("List<", "").replace(">", ""),
-          "[]"
-        );
-      default:
-        return `${fieldName}: json["${fieldName}"] is ${dartType.replace(
-          "?",
-          ""
-        )} ? json["${fieldName}"] : null`;
-    }
-  }
-  if (dartType.includes("List<")) {
-    const innerType = dartType.replace("List<", "").replace(">", "").replace("?", "");
-    return classListTransformer(innerType).fromJsonBody(
-      fieldName,
-      dartType.endsWith("?") ? "null" : "[]"
-    );
-  }
-  const classType = dartType.split("?").join("").trim();
-  return classTransformer(classType, dartType.endsWith("?")).fromJsonBody(
-    fieldName,
-    classType
-  );
-}
-const dartTypeMap = {
-  integer: "int",
-  bigint: "int",
-  number: "double",
-  string: "String",
-  boolean: "bool",
-  null: "null",
-  Date: "DateTime",
-  object: void 0,
-  list: void 0,
-  // eslint-disable-next-line object-shorthand
-  undefined: void 0,
-  array: void 0,
-  Uint8Array: "Uint8List"
-};
-const transformers = {
-  null: {
-    fromJsonBody: (_) => `null`,
-    toJsonBody: defaultToJsonBody
-  },
-  int: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "int", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  double: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "double", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  String: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "String", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  bool: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "bool", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  DateTime: {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is String ? DateTime.parse(json["${key}"]) : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toIso8601String()`
-  },
-  "List<null>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "null", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<int>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "int", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<double>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "double", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<String>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "String", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<bool>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "bool", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<DateTime>": {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List<String> ?
-            (json["${key}"] as List<String>)
-                .map((item) => DateTime.parse(item)).toList() : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toIso8601String()).toList()`
-  },
-  Uint8List: {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List ? Uint8List.fromList(json["${key}"]) : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toList()`
-  },
-  "List<Uint8List>": {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List && (json["${key}"] as List).isNotEmpty && (json["${key}"] as List).first is List ? json["${key}"] : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toList()).toList()`
-  }
-};
-function defaultFromJsonBody(key, typename, fallback) {
-  return `${key}: json["${key}"] is ${typename} ? json["${key}"] : ${fallback}`;
-}
-function defaultListFromJsonBody(key, typename, fallback) {
-  return `${key}: json["${key}"] is List<${typename}> ? json["${key}"] : ${fallback}`;
-}
-function defaultToJsonBody(key) {
-  return `"${key}": ${key}`;
-}
-const classTransformer = (typename, nullable) => {
-  return {
-    fromJsonBody: (key, fallback) => {
-      if (nullable) {
-        return `${key}: json["${key}"] is Map<String, dynamic> ? 
-                ${typename}.fromJson(json["${key}"]) : null`;
-      }
-      return `${key}: ${typename}.fromJson(json["${key}"])`;
-    },
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toJson()`
-  };
-};
-const classListTransformer = (typename) => {
-  return {
-    fromJsonBody: (key, fallback) => {
-      return `${key}: json["${key}"] is List<Map<String, dynamic>> ? 
-                (json["${key}"] as List<Map<String, dynamic>>)
-                    .map((val) => ${typename}.fromJson(val)).toList() : ${fallback}`;
-    },
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toJson()).toList()`
-  };
-};
-function isDartType(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  for (const val of Object.values(dartTypeMap)) {
-    if (input === val) {
-      return true;
-    }
-    if (input.replace("List<", "").replace(">", "") === val) {
-      return true;
-    }
-  }
-  return false;
-}
-function isDartTypeWithNullables(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  for (const val of Object.values(dartTypeMap)) {
-    if (input.replace("?", "") === val) {
-      return true;
-    }
-    if (input.replace("?", "").replace("List<", "").replace(">", "") === val) {
-      return true;
-    }
-  }
-  return false;
-}
-
-exports.classListTransformer = classListTransformer;
-exports.classTransformer = classTransformer;
-exports.createDartClient = createDartClient;
-exports.createTypescriptClient = createTypescriptClient;
-exports.dartClientGenerator = dartClientGenerator;
-exports.dartModelFromJsonSchema = dartModelFromJsonSchema;
-exports.dartParsedJsonField = dartParsedJsonField;
-exports.dartPropertyTypeFromSchema = dartPropertyTypeFromSchema;
-exports.dartServiceFromServiceDefinition = dartServiceFromServiceDefinition;
-exports.defineClientGeneratorPlugin = defineClientGeneratorPlugin;
-exports.isDartType = isDartType;
-exports.isDartTypeWithNullables = isDartTypeWithNullables;
-exports.transformers = transformers;
-exports.tsModelFromDefinition = tsModelFromDefinition;
-exports.tsRpcFromProcedureDefinition = tsRpcFromProcedureDefinition;
-exports.tsServiceFromServiceDefinition = tsServiceFromServiceDefinition;
-exports.typescriptClientGenerator = typescriptClientGenerator;
+exports.format2 = format2;