@cloudflare/deploy-helpers 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -1,16 +1,16 @@
 import { __commonJS, __name, __require, __toESM, fetchListResult, logger, fetchResult, confirm, fetchPagedListResult, prompt, isNonInteractiveOrCI } from './chunk-NAAB7FBS.mjs';
 export { initDeployHelpersContext } from './chunk-NAAB7FBS.mjs';
+import * as path3 from 'node:path';
+import path3__default, { resolve, isAbsolute, dirname, join, extname, sep } from 'node:path';
+import fs2, { readFileSync, statSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import * as z from 'zod';
 import { z as z$1 } from 'zod';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import assert6 from 'node:assert';
-import { readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import * as path from 'node:path';
-import path__default, { resolve, extname, isAbsolute, sep } from 'node:path';
 import url, { URLSearchParams as URLSearchParams$1 } from 'node:url';
 import * as cli from '@cloudflare/cli-shared-helpers';
 import { cancel } from '@cloudflare/cli-shared-helpers';
-import { getEnvironmentVariableFactory, getHostFromRoute, retryOnAPIFailure, UserError, ParseError, getComplianceRegionSubdomain, configFileName, formatTime, getSubdomainMixedStateCheckDisabled, LOGGER_LEVELS, APIError, INHERIT_SYMBOL, COMPLIANCE_REGION_CONFIG_UNKNOWN, constructWranglerConfig, SERVICE_TAG_PREFIX, ENVIRONMENT_TAG_PREFIX, getWranglerTmpDir, getCIMatchTag, FatalError, formatConfigSnippet, readFileSync as readFileSync$1, parseJSON, getBindingTypeFriendlyName, getBindingLocalSupport, assertNever as assertNever$1, experimental_patchConfig, getTodaysCompatDate, getDockerPath, parseNonHyphenedUuid, getWorkersCIBranchName } from '@cloudflare/workers-utils';
+import { getEnvironmentVariableFactory, getHostFromRoute, retryOnAPIFailure, UserError as UserError$1, ParseError as ParseError$1, getComplianceRegionSubdomain, configFileName as configFileName$1, formatTime, getSubdomainMixedStateCheckDisabled, LOGGER_LEVELS, APIError, INHERIT_SYMBOL, COMPLIANCE_REGION_CONFIG_UNKNOWN, constructWranglerConfig, SERVICE_TAG_PREFIX, ENVIRONMENT_TAG_PREFIX, getWranglerTmpDir, getCIMatchTag, FatalError as FatalError$1, formatConfigSnippet as formatConfigSnippet$1, readFileSync as readFileSync$2, parseJSON as parseJSON$1, getBindingTypeFriendlyName, getBindingLocalSupport, assertNever as assertNever$1, experimental_patchConfig, getTodaysCompatDate, getDockerPath, parseNonHyphenedUuid as parseNonHyphenedUuid$1, getWorkersCIBranchName } from '@cloudflare/workers-utils';
 import { spawnSync, execSync, spawn } from 'node:child_process';
 import { FormData, Response } from 'undici';
 import chalk5 from 'chalk';
@@ -24,7 +24,7 @@ import { brandColor, white, gray, dim, blue } from '@cloudflare/cli-shared-helpe
 import { inputPrompt, leftT } from '@cloudflare/cli-shared-helpers/interactive';
 import { sync } from 'command-exists';
 import readline from 'node:readline';
-import { parse } from 'dotenv';
+import { parse as parse$1 } from 'dotenv';
 import { stripVTControlCharacters } from 'node:util';
 import { getFreshSourceMapSupport, getNodeCompat } from 'miniflare';
 import { createHash } from 'node:crypto';
@@ -256,17 +256,17 @@ var require_ignore = __commonJS({
     var throwError = /* @__PURE__ */ __name((message, Ctor) => {
       throw new Ctor(message);
     }, "throwError");
-    var checkPath = /* @__PURE__ */ __name((path8, originalPath, doThrow) => {
-      if (!isString(path8)) {
+    var checkPath = /* @__PURE__ */ __name((path9, originalPath, doThrow) => {
+      if (!isString(path9)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path8) {
+      if (!path9) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path8)) {
+      if (checkPath.isNotRelative(path9)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -275,7 +275,7 @@ var require_ignore = __commonJS({
       }
       return true;
     }, "checkPath");
-    var isNotRelative = /* @__PURE__ */ __name((path8) => REGEX_TEST_INVALID_PATH.test(path8), "isNotRelative");
+    var isNotRelative = /* @__PURE__ */ __name((path9) => REGEX_TEST_INVALID_PATH.test(path9), "isNotRelative");
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -337,7 +337,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path8, checkUnignored) {
+      _testOne(path9, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -345,7 +345,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path8);
+          const matched = rule.regex.test(path9);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -358,24 +358,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path8 = originalPath && checkPath.convert(originalPath);
+        const path9 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path8,
+          path9,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path8, cache, checkUnignored, slices);
+        return this._t(path9, cache, checkUnignored, slices);
       }
-      _t(path8, cache, checkUnignored, slices) {
-        if (path8 in cache) {
-          return cache[path8];
+      _t(path9, cache, checkUnignored, slices) {
+        if (path9 in cache) {
+          return cache[path9];
         }
         if (!slices) {
-          slices = path8.split(SLASH);
+          slices = path9.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path8] = this._testOne(path8, checkUnignored);
+          return cache[path9] = this._testOne(path9, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -383,24 +383,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
+        return cache[path9] = parent.ignored ? parent : this._testOne(path9, checkUnignored);
       }
-      ignores(path8) {
-        return this._test(path8, this._ignoreCache, false).ignored;
+      ignores(path9) {
+        return this._test(path9, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path8) => !this.ignores(path8);
+        return (path9) => !this.ignores(path9);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path8) {
-        return this._test(path8, this._testCache, true);
+      test(path9) {
+        return this._test(path9, this._testCache, true);
       }
     };
     var factory = /* @__PURE__ */ __name((options) => new Ignore(options), "factory");
-    var isPathValid = /* @__PURE__ */ __name((path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE), "isPathValid");
+    var isPathValid = /* @__PURE__ */ __name((path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE), "isPathValid");
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -411,7 +411,7 @@ var require_ignore = __commonJS({
       const makePosix = /* @__PURE__ */ __name((str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/"), "makePosix");
       checkPath.convert = makePosix;
       const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
+      checkPath.isNotRelative = (path9) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path9) || isNotRelative(path9);
     }
   }
 });
@@ -1648,7 +1648,7 @@ var require_difflib2 = __commonJS({
 // ../../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/util.js
 var require_util = __commonJS({
   "../../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/util.js"(exports, module) {
-    var extendedTypeOf = /* @__PURE__ */ __name(function(obj) {
+    var extendedTypeOf2 = /* @__PURE__ */ __name(function(obj) {
       const result = typeof obj;
       if (obj == null) {
         return "null";
@@ -1675,7 +1675,7 @@ var require_util = __commonJS({
         return data;
       }
     }, "roundObj");
-    module.exports = { extendedTypeOf, roundObj };
+    module.exports = { extendedTypeOf: extendedTypeOf2, roundObj };
   }
 });
 
@@ -2351,7 +2351,7 @@ var require_safe = __commonJS({
 var require_colorize = __commonJS({
   "../../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/colorize.js"(exports, module) {
     var color = require_safe();
-    var { extendedTypeOf } = require_util();
+    var { extendedTypeOf: extendedTypeOf2 } = require_util();
     var Theme = {
       " "(s) {
         return s;
@@ -2373,7 +2373,7 @@ var require_colorize = __commonJS({
           output(" ", subindent + `... (${n} entries)`);
         }
       }, "outputElisions");
-      switch (extendedTypeOf(diff)) {
+      switch (extendedTypeOf2(diff)) {
         case "object":
           if ("__old" in diff && "__new" in diff && Object.keys(diff).length === 2) {
             subcolorizeToCallback(options, key, diff.__old, output, "-", indent);
@@ -2397,7 +2397,7 @@ var require_colorize = __commonJS({
           output(color2, `${indent}${prefix}[`);
           let looksLikeDiff = true;
           for (const item of diff) {
-            if (extendedTypeOf(item) !== "array" || !(item.length === 2 || item.length === 1 && item[0] === " ") || !(typeof item[0] === "string") || item[0].length !== 1 || ![" ", "-", "+", "~"].includes(item[0])) {
+            if (extendedTypeOf2(item) !== "array" || !(item.length === 2 || item.length === 1 && item[0] === " ") || !(typeof item[0] === "string") || item[0].length !== 1 || ![" ", "-", "+", "~"].includes(item[0])) {
               looksLikeDiff = false;
             }
           }
@@ -2463,7 +2463,7 @@ var require_colorize = __commonJS({
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/index.js"(exports, module) {
     var { SequenceMatcher } = require_difflib2();
-    var { extendedTypeOf, roundObj } = require_util();
+    var { extendedTypeOf: extendedTypeOf2, roundObj } = require_util();
     var { colorize, colorizeToCallback } = require_colorize();
     var JsonDiff = class {
       static {
@@ -2531,7 +2531,7 @@ var require_lib = __commonJS({
         for (const [key, { item: candidate, index: matchIndex }] of Object.entries(fuzzyOriginals)) {
           if (key !== "__next") {
             const indexDistance = Math.abs(matchIndex - index);
-            if (extendedTypeOf(item) === extendedTypeOf(candidate)) {
+            if (extendedTypeOf2(item) === extendedTypeOf2(candidate)) {
               const { score } = this.diff(item, candidate);
               if (!bestMatch || score > bestMatch.score || score === bestMatch.score && indexDistance < bestMatch.indexDistance) {
                 bestMatch = { score, key, indexDistance };
@@ -2693,8 +2693,8 @@ var require_lib = __commonJS({
         return { score, result, equal };
       }
       diff(obj1, obj2) {
-        const type1 = extendedTypeOf(obj1);
-        const type2 = extendedTypeOf(obj2);
+        const type1 = extendedTypeOf2(obj1);
+        const type2 = extendedTypeOf2(obj2);
         if (type1 === type2) {
           switch (type1) {
             case "object":
@@ -2748,6 +2748,2632 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __commonJS2 = /* @__PURE__ */ __name((cb, mod) => function() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 }, "__commonJS");
+var __defProp = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+var UserError = class extends Error {
+  static {
+    __name(this, "UserError");
+  }
+  static {
+    __name2(this, "UserError");
+  }
+  telemetryMessage;
+  constructor(message, options) {
+    super(message, options);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.telemetryMessage = typeof options?.telemetryMessage === "string" ? options.telemetryMessage : options?.telemetryMessage ? message : void 0;
+  }
+};
+(class extends UserError {
+  static {
+    __name(this, "DeprecationError");
+  }
+  static {
+    __name2(this, "DeprecationError");
+  }
+  constructor(message, options) {
+    super(`Deprecation:
+${message}`, options);
+  }
+});
+var FatalError = class extends UserError {
+  static {
+    __name(this, "FatalError");
+  }
+  static {
+    __name2(this, "FatalError");
+  }
+  code;
+  constructor(message, options) {
+    super(message, options);
+    this.code = options.code;
+  }
+};
+(class extends UserError {
+  static {
+    __name(this, "CommandLineArgsError");
+  }
+  static {
+    __name2(this, "CommandLineArgsError");
+  }
+});
+var JsonFriendlyFatalError = class extends FatalError {
+  static {
+    __name(this, "JsonFriendlyFatalError");
+  }
+  static {
+    __name2(this, "JsonFriendlyFatalError");
+  }
+};
+(class extends Error {
+  static {
+    __name(this, "MissingConfigError");
+  }
+  static {
+    __name2(this, "MissingConfigError");
+  }
+  telemetryMessage;
+  constructor(key) {
+    super(`Missing config value for ${key}`);
+    this.telemetryMessage = `Missing config value for ${key}`;
+  }
+});
+function createFatalError(message, isJson, options) {
+  if (isJson) return new JsonFriendlyFatalError(JSON.stringify(message), options);
+  return new FatalError(`${message}`, options);
+}
+__name(createFatalError, "createFatalError");
+__name2(createFatalError, "createFatalError");
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) value2 = value2 * 16 + ch - 48;
+      else if (ch >= 65 && ch <= 70) value2 = value2 * 16 + ch - 65 + 10;
+      else if (ch >= 97 && ch <= 102) value2 = value2 * 16 + ch - 97 + 10;
+      else break;
+      pos++;
+      digits++;
+    }
+    if (digits < count) value2 = -1;
+    return value2;
+  }
+  __name(scanHexDigits, "scanHexDigits");
+  __name2(scanHexDigits, "scanHexDigits");
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  __name(setPosition, "setPosition");
+  __name2(setPosition, "setPosition");
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) pos++;
+    else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) pos++;
+        end = pos;
+      } else scanError = 3;
+    }
+    return text.substring(start, end);
+  }
+  __name(scanNumber, "scanNumber");
+  __name2(scanNumber, "scanNumber");
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        switch (text.charCodeAt(pos++)) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) result += String.fromCharCode(ch3);
+            else scanError = 4;
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) if (isLineBreak(ch)) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      } else scanError = 6;
+      pos++;
+    }
+    return result;
+  }
+  __name(scanString, "scanString");
+  __name2(scanString, "scanString");
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) break;
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) pos++;
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) return token = 16;
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  __name(scanNext, "scanNext");
+  __name2(scanNext, "scanNext");
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) return false;
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  __name(isUnknownContentCharacter, "isUnknownContentCharacter");
+  __name2(isUnknownContentCharacter, "isUnknownContentCharacter");
+  function scanNextNonTrivia() {
+    let result;
+    do
+      result = scanNext();
+    while (result >= 12 && result <= 15);
+    return result;
+  }
+  __name(scanNextNonTrivia, "scanNextNonTrivia");
+  __name2(scanNextNonTrivia, "scanNextNonTrivia");
+  return {
+    setPosition,
+    getPosition: /* @__PURE__ */ __name2(() => pos, "getPosition"),
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: /* @__PURE__ */ __name2(() => token, "getToken"),
+    getTokenValue: /* @__PURE__ */ __name2(() => value, "getTokenValue"),
+    getTokenOffset: /* @__PURE__ */ __name2(() => tokenOffset, "getTokenOffset"),
+    getTokenLength: /* @__PURE__ */ __name2(() => pos - tokenOffset, "getTokenLength"),
+    getTokenStartLine: /* @__PURE__ */ __name2(() => lineStartOffset, "getTokenStartLine"),
+    getTokenStartCharacter: /* @__PURE__ */ __name2(() => tokenOffset - prevTokenLineStartOffset, "getTokenStartCharacter"),
+    getTokenError: /* @__PURE__ */ __name2(() => scanError, "getTokenError")
+  };
+}
+__name(createScanner, "createScanner");
+__name2(createScanner, "createScanner");
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+__name(isWhiteSpace, "isWhiteSpace");
+__name2(isWhiteSpace, "isWhiteSpace");
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+__name(isLineBreak, "isLineBreak");
+__name2(isLineBreak, "isLineBreak");
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+__name(isDigit, "isDigit");
+__name2(isDigit, "isDigit");
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) formatTextStart--;
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) endOffset++;
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) indentValue = repeat(" ", options.tabSize || 4);
+  else indentValue = "	";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    else return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+  }
+  __name(newLinesAndIndent, "newLinesAndIndent");
+  __name2(newLinesAndIndent, "newLinesAndIndent");
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) numberLineBreaks += 1;
+      else if (token === 14) numberLineBreaks = 1;
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  __name(scanNext, "scanNext");
+  __name2(scanNext, "scanNext");
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) editOperations.push({
+      offset: startOffset,
+      length: endOffset - startOffset,
+      content: text
+    });
+  }
+  __name(addEdit, "addEdit");
+  __name2(addEdit, "addEdit");
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(repeat(indentValue, initialIndentLevel), formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(" ", firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) indentLevel--;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) replaceContent = newLinesAndIndent();
+      else if (options.keepLines) replaceContent = " ";
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) indentLevel--;
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) replaceContent = newLinesAndIndent();
+      else if (options.keepLines) replaceContent = " ";
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+          else replaceContent = " ";
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) replaceContent = newLinesAndIndent();
+          else replaceContent = " ";
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+          else if (!needsLineBreak) replaceContent = " ";
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+          else if (!needsLineBreak) replaceContent = " ";
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+          else if (secondToken === 6 && !needsLineBreak) replaceContent = "";
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+          else if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) replaceContent = " ";
+          else if (secondToken !== 5 && secondToken !== 17) hasError = true;
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) replaceContent = newLinesAndIndent();
+    }
+    if (secondToken === 17) if (options.keepLines && numberLineBreaks > 0) replaceContent = newLinesAndIndent();
+    else replaceContent = options.insertFinalNewline ? eol : "";
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+__name(format, "format");
+__name2(format, "format");
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0; i < count; i++) result += s;
+  return result;
+}
+__name(repeat, "repeat");
+__name2(repeat, "repeat");
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === " ") nChars++;
+    else if (ch === "	") nChars += tabSize;
+    else break;
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+__name(computeIndentLevel, "computeIndentLevel");
+__name2(computeIndentLevel, "computeIndentLevel");
+function getEOL(options, text) {
+  for (let i = 0; i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === "\n") return "\r\n";
+      return "\r";
+    } else if (ch === "\n") return "\n";
+  }
+  return options && options.eol || "\n";
+}
+__name(getEOL, "getEOL");
+__name2(getEOL, "getEOL");
+function isEOL(text, offset) {
+  return "\r\n".indexOf(text.charAt(offset)) !== -1;
+}
+__name(isEOL, "isEOL");
+__name2(isEOL, "isEOL");
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = { allowTrailingComma: false };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) currentParent.push(value);
+    else if (currentProperty !== null) currentParent[currentProperty] = value;
+  }
+  __name(onValue, "onValue");
+  __name2(onValue, "onValue");
+  visit(text, {
+    onObjectBegin: /* @__PURE__ */ __name2(() => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    }, "onObjectBegin"),
+    onObjectProperty: /* @__PURE__ */ __name2((name) => {
+      currentProperty = name;
+    }, "onObjectProperty"),
+    onObjectEnd: /* @__PURE__ */ __name2(() => {
+      currentParent = previousParents.pop();
+    }, "onObjectEnd"),
+    onArrayBegin: /* @__PURE__ */ __name2(() => {
+      const array2 = [];
+      onValue(array2);
+      previousParents.push(currentParent);
+      currentParent = array2;
+      currentProperty = null;
+    }, "onArrayBegin"),
+    onArrayEnd: /* @__PURE__ */ __name2(() => {
+      currentParent = previousParents.pop();
+    }, "onArrayEnd"),
+    onLiteralValue: onValue,
+    onError: /* @__PURE__ */ __name2((error, offset, length) => {
+      errors.push({
+        error,
+        offset,
+        length
+      });
+    }, "onError")
+  }, options);
+  return currentParent[0];
+}
+__name(parse, "parse");
+__name2(parse, "parse");
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = {
+    type: "array",
+    offset: -1,
+    length: -1,
+    children: [],
+    parent: void 0
+  };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  __name(ensurePropertyComplete, "ensurePropertyComplete");
+  __name2(ensurePropertyComplete, "ensurePropertyComplete");
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  __name(onValue, "onValue");
+  __name2(onValue, "onValue");
+  visit(text, {
+    onObjectBegin: /* @__PURE__ */ __name2((offset) => {
+      currentParent = onValue({
+        type: "object",
+        offset,
+        length: -1,
+        parent: currentParent,
+        children: []
+      });
+    }, "onObjectBegin"),
+    onObjectProperty: /* @__PURE__ */ __name2((name, offset, length) => {
+      currentParent = onValue({
+        type: "property",
+        offset,
+        length: -1,
+        parent: currentParent,
+        children: []
+      });
+      currentParent.children.push({
+        type: "string",
+        value: name,
+        offset,
+        length,
+        parent: currentParent
+      });
+    }, "onObjectProperty"),
+    onObjectEnd: /* @__PURE__ */ __name2((offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    }, "onObjectEnd"),
+    onArrayBegin: /* @__PURE__ */ __name2((offset, length) => {
+      currentParent = onValue({
+        type: "array",
+        offset,
+        length: -1,
+        parent: currentParent,
+        children: []
+      });
+    }, "onArrayBegin"),
+    onArrayEnd: /* @__PURE__ */ __name2((offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    }, "onArrayEnd"),
+    onLiteralValue: /* @__PURE__ */ __name2((value, offset, length) => {
+      onValue({
+        type: getNodeType(value),
+        offset,
+        length,
+        parent: currentParent,
+        value
+      });
+      ensurePropertyComplete(offset + length);
+    }, "onLiteralValue"),
+    onSeparator: /* @__PURE__ */ __name2((sep2, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep2 === ":") currentParent.colonOffset = offset;
+        else if (sep2 === ",") ensurePropertyComplete(offset);
+      }
+    }, "onSeparator"),
+    onError: /* @__PURE__ */ __name2((error, offset, length) => {
+      errors.push({
+        error,
+        offset,
+        length
+      });
+    }, "onError")
+  }, options);
+  const result = currentParent.children[0];
+  if (result) delete result.parent;
+  return result;
+}
+__name(parseTree, "parseTree");
+__name2(parseTree, "parseTree");
+function findNodeAtLocation(root, path22) {
+  if (!root) return;
+  let node = root;
+  for (let segment of path22) if (typeof segment === "string") {
+    if (node.type !== "object" || !Array.isArray(node.children)) return;
+    let found = false;
+    for (const propertyNode of node.children) if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+      node = propertyNode.children[1];
+      found = true;
+      break;
+    }
+    if (!found) return;
+  } else {
+    const index = segment;
+    if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) return;
+    node = node.children[index];
+  }
+  return node;
+}
+__name(findNodeAtLocation, "findNodeAtLocation");
+__name2(findNodeAtLocation, "findNodeAtLocation");
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  __name(toNoArgVisit, "toNoArgVisit");
+  __name2(toNoArgVisit, "toNoArgVisit");
+  function toNoArgVisitWithPath(visitFunction) {
+    return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  __name(toNoArgVisitWithPath, "toNoArgVisitWithPath");
+  __name2(toNoArgVisitWithPath, "toNoArgVisitWithPath");
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  __name(toOneArgVisit, "toOneArgVisit");
+  __name2(toOneArgVisit, "toOneArgVisit");
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  __name(toOneArgVisitWithPath, "toOneArgVisitWithPath");
+  __name2(toOneArgVisitWithPath, "toOneArgVisitWithPath");
+  const onObjectBegin = toNoArgVisitWithPath(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisitWithPath(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) handleError(11);
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) handleError(10);
+          else onComment();
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  __name(scanNext, "scanNext");
+  __name2(scanNext, "scanNext");
+  function handleError(error, skipUntilAfter = [], skipUntil2 = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil2.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil2.indexOf(token) !== -1) break;
+        token = scanNext();
+      }
+    }
+  }
+  __name(handleError, "handleError");
+  __name2(handleError, "handleError");
+  function parseString2(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) onLiteralValue(value);
+    else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  __name(parseString2, "parseString2");
+  __name2(parseString2, "parseString");
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  __name(parseLiteral, "parseLiteral");
+  __name2(parseLiteral, "parseLiteral");
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString2(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue2()) handleError(4, [], [2, 5]);
+    } else handleError(5, [], [2, 5]);
+    _jsonPath.pop();
+    return true;
+  }
+  __name(parseProperty, "parseProperty");
+  __name2(parseProperty, "parseProperty");
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) handleError(4, [], []);
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) break;
+      } else if (needsComma) handleError(6, [], []);
+      if (!parseProperty()) handleError(4, [], [2, 5]);
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) handleError(7, [2], []);
+    else scanNext();
+    return true;
+  }
+  __name(parseObject, "parseObject");
+  __name2(parseObject, "parseObject");
+  function parseArray2() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) handleError(4, [], []);
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) break;
+      } else if (needsComma) handleError(6, [], []);
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else _jsonPath[_jsonPath.length - 1]++;
+      if (!parseValue2()) handleError(4, [], [4, 5]);
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) _jsonPath.pop();
+    if (_scanner.getToken() !== 4) handleError(8, [4], []);
+    else scanNext();
+    return true;
+  }
+  __name(parseArray2, "parseArray2");
+  __name2(parseArray2, "parseArray");
+  function parseValue2() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray2();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString2(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  __name(parseValue2, "parseValue2");
+  __name2(parseValue2, "parseValue");
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) return true;
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue2()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) handleError(9, [], []);
+  return true;
+}
+__name(visit, "visit");
+__name2(visit, "visit");
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object":
+      if (!value) return "null";
+      else if (Array.isArray(value)) return "array";
+      return "object";
+    default:
+      return "null";
+  }
+}
+__name(getNodeType, "getNodeType");
+__name2(getNodeType, "getNodeType");
+function setProperty(text, originalPath, value, options) {
+  const path22 = originalPath.slice();
+  const root = parseTree(text, []);
+  let parent = void 0;
+  let lastSegment = void 0;
+  while (path22.length > 0) {
+    lastSegment = path22.pop();
+    parent = findNodeAtLocation(root, path22);
+    if (parent === void 0 && value !== void 0) if (typeof lastSegment === "string") value = { [lastSegment]: value };
+    else value = [value];
+    else break;
+  }
+  if (!parent) {
+    if (value === void 0) throw new Error("Can not delete in empty document");
+    return withFormatting(text, {
+      offset: root ? root.offset : 0,
+      length: root ? root.length : 0,
+      content: JSON.stringify(value)
+    }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== void 0) if (value === void 0) {
+      if (!existing.parent) throw new Error("Malformed AST");
+      const propertyIndex = parent.children.indexOf(existing.parent);
+      let removeBegin;
+      let removeEnd = existing.parent.offset + existing.parent.length;
+      if (propertyIndex > 0) {
+        let previous = parent.children[propertyIndex - 1];
+        removeBegin = previous.offset + previous.length;
+      } else {
+        removeBegin = parent.offset + 1;
+        if (parent.children.length > 1) removeEnd = parent.children[1].offset;
+      }
+      return withFormatting(text, {
+        offset: removeBegin,
+        length: removeEnd - removeBegin,
+        content: ""
+      }, options);
+    } else return withFormatting(text, {
+      offset: existing.offset,
+      length: existing.length,
+      content: JSON.stringify(value)
+    }, options);
+    else {
+      if (value === void 0) return [];
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = {
+          offset: previous.offset + previous.length,
+          length: 0,
+          content: "," + newProperty
+        };
+      } else if (parent.children.length === 0) edit = {
+        offset: parent.offset + 1,
+        length: 0,
+        content: newProperty
+      };
+      else edit = {
+        offset: parent.offset + 1,
+        length: 0,
+        content: newProperty + ","
+      };
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) edit = {
+        offset: parent.offset + 1,
+        length: 0,
+        content: newProperty
+      };
+      else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = {
+          offset: previous.offset + previous.length,
+          length: 0,
+          content: "," + newProperty
+        };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === void 0 && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) edit = {
+        offset: parent.offset + 1,
+        length: parent.length - 2,
+        content: ""
+      };
+      else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        edit = {
+          offset,
+          length: parent.offset + parent.length - 2 - offset,
+          content: ""
+        };
+      } else edit = {
+        offset: toRemove.offset,
+        length: parent.children[removalIndex + 1].offset - toRemove.offset,
+        content: ""
+      };
+      return withFormatting(text, edit, options);
+    } else if (value !== void 0) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = {
+          offset: toModify.offset,
+          length: toModify.length,
+          content: newProperty
+        };
+      } else if (parent.children.length === 0 || lastSegment === 0) edit = {
+        offset: parent.offset + 1,
+        length: 0,
+        content: parent.children.length === 0 ? newProperty : newProperty + ","
+      };
+      else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = {
+          offset: previous.offset + previous.length,
+          length: 0,
+          content: "," + newProperty
+        };
+      }
+      return withFormatting(text, edit, options);
+    } else throw new Error(`Can not ${value === void 0 ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+  } else throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+}
+__name(setProperty, "setProperty");
+__name2(setProperty, "setProperty");
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) return [edit];
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) begin--;
+    while (end < newText.length && !isEOL(newText, end)) end++;
+  }
+  const edits = format(newText, {
+    offset: begin,
+    length: end - begin
+  }, {
+    ...options.formattingOptions,
+    keepLines: false
+  });
+  for (let i = edits.length - 1; i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{
+    offset: begin,
+    length: editLength,
+    content: newText.substring(begin, end)
+  }];
+}
+__name(withFormatting, "withFormatting");
+__name2(withFormatting, "withFormatting");
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
+__name(applyEdit, "applyEdit");
+__name2(applyEdit, "applyEdit");
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+function printParseErrorCode(code) {
+  switch (code) {
+    case 1:
+      return "InvalidSymbol";
+    case 2:
+      return "InvalidNumberFormat";
+    case 3:
+      return "PropertyNameExpected";
+    case 4:
+      return "ValueExpected";
+    case 5:
+      return "ColonExpected";
+    case 6:
+      return "CommaExpected";
+    case 7:
+      return "CloseBraceExpected";
+    case 8:
+      return "CloseBracketExpected";
+    case 9:
+      return "EndOfFileExpected";
+    case 10:
+      return "InvalidCommentToken";
+    case 11:
+      return "UnexpectedEndOfComment";
+    case 12:
+      return "UnexpectedEndOfString";
+    case 13:
+      return "UnexpectedEndOfNumber";
+    case 14:
+      return "InvalidUnicode";
+    case 15:
+      return "InvalidEscapeCharacter";
+    case 16:
+      return "InvalidCharacter";
+  }
+  return "<unknown ParseErrorCode>";
+}
+__name(printParseErrorCode, "printParseErrorCode");
+__name2(printParseErrorCode, "printParseErrorCode");
+function format2(documentText, range, options) {
+  return format(documentText, range, options);
+}
+__name(format2, "format2");
+__name2(format2, "format");
+function modify(text, path22, value, options) {
+  return setProperty(text, path22, value, options);
+}
+__name(modify, "modify");
+__name2(modify, "modify");
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) return a.length - b.length;
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1; i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) text = applyEdit(text, e);
+    else throw new Error("Overlapping edit");
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
+__name(applyEdits, "applyEdits");
+__name2(applyEdits, "applyEdits");
+function getLineColFromPtr(string2, ptr) {
+  let lines = string2.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+__name(getLineColFromPtr, "getLineColFromPtr");
+__name2(getLineColFromPtr, "getLineColFromPtr");
+function makeCodeBlock(string2, line, column) {
+  let lines = string2.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l) continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+__name(makeCodeBlock, "makeCodeBlock");
+__name2(makeCodeBlock, "makeCodeBlock");
+var TomlError = class extends Error {
+  static {
+    __name(this, "TomlError");
+  }
+  static {
+    __name2(this, "TomlError");
+  }
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\") ;
+  return --i && i % 2;
+}
+__name(isEscaped, "isEscaped");
+__name2(isEscaped, "isEscaped");
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r") idx--;
+  return idx <= end ? idx : -1;
+}
+__name(indexOfNewline, "indexOfNewline");
+__name2(indexOfNewline, "indexOfNewline");
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n") return i;
+    if (c === "\r" && str[i + 1] === "\n") return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") throw new TomlError("control characters are not allowed in comments", {
+      toml: str,
+      ptr
+    });
+  }
+  return str.length;
+}
+__name(skipComment, "skipComment");
+__name2(skipComment, "skipComment");
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n")) ptr++;
+  return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+__name(skipVoid, "skipVoid");
+__name2(skipVoid, "skipVoid");
+function skipUntil(str, ptr, sep2, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") i = indexOfNewline(str, i);
+    else if (c === sep2) return i + 1;
+    else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) return i;
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+__name(skipUntil, "skipUntil");
+__name2(skipUntil, "skipUntil");
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first) seek++;
+      if (str[seek] === first) seek++;
+    }
+  }
+  return seek;
+}
+__name(getStringEnd, "getStringEnd");
+__name2(getStringEnd, "getStringEnd");
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}:\d{2}(?:\.\d+)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  static {
+    __name(this, "_TomlDate");
+  }
+  static {
+    __name2(this, "TomlDate");
+  }
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) date = "";
+        else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime) date += "Z";
+        }
+      } else date = "";
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate()) return iso.slice(0, 10);
+    if (this.isTime()) return iso.slice(11, 23);
+    if (this.#offset === null) return iso.slice(0, -1);
+    if (this.#offset === "Z") return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    return (/* @__PURE__ */ new Date(this.getTime() - offset * 6e4)).toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{4,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "	",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r") ptr++;
+    if (str[ptr] === "\n") ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+      if (!isMultiline) throw new TomlError("newlines are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c < " " && c !== "	" || c === "\x7F") throw new TomlError("control characters are not allowed in strings", {
+      toml: str,
+      ptr: ptr - 1
+    });
+    if (isEscape) {
+      isEscape = false;
+      if (c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) throw new TomlError("invalid unicode escape", {
+          toml: str,
+          ptr: tmp
+        });
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== "\n" && str[ptr] !== "\r") throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: str,
+          ptr: tmp
+        });
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) parsed += ESC_MAP[c];
+      else throw new TomlError("unrecognized escape sequence", {
+        toml: str,
+        ptr: tmp
+      });
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
+}
+__name(parseString, "parseString");
+__name2(parseString, "parseString");
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "-inf") return -Infinity;
+  if (value === "inf" || value === "+inf") return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan") return NaN;
+  if (value === "-0") return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) throw new TomlError("leading zeroes are not allowed", {
+      toml,
+      ptr
+    });
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) throw new TomlError("invalid number", {
+      toml,
+      ptr
+    });
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) throw new TomlError("integer value cannot be represented losslessly", {
+        toml,
+        ptr
+      });
+      if (isInt || integersAsBigInt === true) numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) throw new TomlError("invalid value", {
+    toml,
+    ptr
+  });
+  return date;
+}
+__name(parseValue, "parseValue");
+__name2(parseValue, "parseValue");
+function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  let trimmed = value.trimEnd();
+  if (!allowNewLines) {
+    let newlineIdx = value.indexOf("\n", trimmed.length);
+    if (newlineIdx > -1) throw new TomlError("newlines are not allowed in inline tables", {
+      toml: str,
+      ptr: startPtr + newlineIdx
+    });
+  }
+  return [trimmed, commentIdx];
+}
+__name(sliceAndTrimEndOf, "sliceAndTrimEndOf");
+__name2(sliceAndTrimEndOf, "sliceAndTrimEndOf");
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) throw new TomlError("document contains excessively nested structures. aborting.", {
+    toml: str,
+    ptr
+  });
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    let newPtr = end ? skipUntil(str, endPtr2, ",", end) : endPtr2;
+    if (endPtr2 - newPtr && end === "}") {
+      let nextNewLine = indexOfNewline(str, endPtr2, newPtr);
+      if (nextNewLine > -1) throw new TomlError("newlines are not allowed in inline tables", {
+        toml: str,
+        ptr: nextNewLine
+      });
+    }
+    return [value, newPtr];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr, end !== "]");
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") throw new TomlError("unexpected character encountered", {
+        toml: str,
+        ptr: endPtr
+      });
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","), end === "]");
+  if (!slice[0]) throw new TomlError("incomplete key-value declaration: no value specified", {
+    toml: str,
+    ptr
+  });
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [parseValue(slice[0], str, ptr, integersAsBigInt), endPtr];
+}
+__name(extractValue, "extractValue");
+__name2(extractValue, "extractValue");
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+    toml: str,
+    ptr
+  });
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") if (c === '"' || c === "'") {
+      if (c === str[ptr + 1] && c === str[ptr + 2]) throw new TomlError("multiline strings are not allowed in keys", {
+        toml: str,
+        ptr
+      });
+      let eos = getStringEnd(str, ptr);
+      if (eos < 0) throw new TomlError("unfinished string encountered", {
+        toml: str,
+        ptr
+      });
+      dot = str.indexOf(".", eos);
+      let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+      let newLine = indexOfNewline(strEnd);
+      if (newLine > -1) throw new TomlError("newlines are not allowed in keys", {
+        toml: str,
+        ptr: ptr + dot + newLine
+      });
+      if (strEnd.trimStart()) throw new TomlError("found extra tokens after the string part", {
+        toml: str,
+        ptr: eos
+      });
+      if (endPtr < eos) {
+        endPtr = str.indexOf(end, eos);
+        if (endPtr < 0) throw new TomlError("incomplete key-value: cannot find end of key", {
+          toml: str,
+          ptr
+        });
+      }
+      parsed.push(parseString(str, ptr, eos));
+    } else {
+      dot = str.indexOf(".", ptr);
+      let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+      if (!KEY_PART_RE.test(part)) throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+        toml: str,
+        ptr
+      });
+      parsed.push(part.trimEnd());
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+__name(parseKey, "parseKey");
+__name2(parseKey, "parseKey");
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  let comma = 0;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    let err = {
+      toml: str,
+      ptr: ptr - 1
+    };
+    if (c === "\n") throw new TomlError("newlines are not allowed in inline tables", err);
+    else if (c === "#") throw new TomlError("inline tables cannot contain comments", err);
+    else if (c === ",") throw new TomlError("expected key-value, found comma", err);
+    else if (c !== " " && c !== "	") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i) t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+        if (!hasOwn && k === "__proto__") Object.defineProperty(t, k, {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      }
+      if (hasOwn) throw new TomlError("trying to redefine an already defined value", {
+        toml: str,
+        ptr
+      });
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+      comma = str[ptr - 1] === "," ? ptr - 1 : 0;
+    }
+  }
+  if (comma) throw new TomlError("trailing commas are not allowed in inline tables", {
+    toml: str,
+    ptr: comma
+  });
+  if (!c) throw new TomlError("unfinished table encountered", {
+    toml: str,
+    ptr
+  });
+  return [res, ptr];
+}
+__name(parseInlineTable, "parseInlineTable");
+__name2(parseInlineTable, "parseInlineTable");
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) if (c === ",") throw new TomlError("expected value, found comma", {
+    toml: str,
+    ptr: ptr - 1
+  });
+  else if (c === "#") ptr = skipComment(str, ptr);
+  else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+    let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+    res.push(e[0]);
+    ptr = e[1];
+  }
+  if (!c) throw new TomlError("unfinished array encountered", {
+    toml: str,
+    ptr
+  });
+  return [res, ptr];
+}
+__name(parseArray, "parseArray");
+__name2(parseArray, "parseArray");
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) return null;
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) return null;
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+        Object.defineProperty(m, k, {
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) return null;
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = {
+      t: 1,
+      d: false,
+      i: 0,
+      c: {}
+    };
+  }
+  if (state.d) return null;
+  state.d = true;
+  if (type === 1) t = hasOwn ? t[k] : t[k] = {};
+  else if (type === 0 && hasOwn) return null;
+  return [
+    k,
+    t,
+    state.c
+  ];
+}
+__name(peekTable, "peekTable");
+__name2(peekTable, "peekTable");
+function parse3(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") throw new TomlError("expected end of table declaration", {
+          toml,
+          ptr: k[1] - 1
+        });
+        k[1]++;
+      }
+      let p = peekTable(k[0], res, meta, isTableArray ? 2 : 1);
+      if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+        toml,
+        ptr
+      });
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(k[0], tbl, m, 0);
+      if (!p) throw new TomlError("trying to redefine an already defined table or value", {
+        toml,
+        ptr
+      });
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+      toml,
+      ptr
+    });
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+__name(parse3, "parse3");
+__name2(parse3, "parse");
+var BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+  let type = typeof obj;
+  if (type === "object") {
+    if (Array.isArray(obj)) return "array";
+    if (obj instanceof Date) return "date";
+  }
+  return type;
+}
+__name(extendedTypeOf, "extendedTypeOf");
+__name2(extendedTypeOf, "extendedTypeOf");
+function isArrayOfTables(obj) {
+  for (let i = 0; i < obj.length; i++) if (extendedTypeOf(obj[i]) !== "object") return false;
+  return obj.length != 0;
+}
+__name(isArrayOfTables, "isArrayOfTables");
+__name2(isArrayOfTables, "isArrayOfTables");
+function formatString(s) {
+  return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
+}
+__name(formatString, "formatString");
+__name2(formatString, "formatString");
+function stringifyValue(val, type, depth, numberAsFloat) {
+  if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+  if (type === "number") {
+    if (isNaN(val)) return "nan";
+    if (val === Infinity) return "inf";
+    if (val === -Infinity) return "-inf";
+    if (numberAsFloat && Number.isInteger(val)) return val.toFixed(1);
+    return val.toString();
+  }
+  if (type === "bigint" || type === "boolean") return val.toString();
+  if (type === "string") return formatString(val);
+  if (type === "date") {
+    if (isNaN(val.getTime())) throw new TypeError("cannot serialize invalid date");
+    return val.toISOString();
+  }
+  if (type === "object") return stringifyInlineTable(val, depth, numberAsFloat);
+  if (type === "array") return stringifyArray(val, depth, numberAsFloat);
+}
+__name(stringifyValue, "stringifyValue");
+__name2(stringifyValue, "stringifyValue");
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+  let keys = Object.keys(obj);
+  if (keys.length === 0) return "{}";
+  let res = "{ ";
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (i) res += ", ";
+    res += BARE_KEY.test(k) ? k : formatString(k);
+    res += " = ";
+    res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+  }
+  return res + " }";
+}
+__name(stringifyInlineTable, "stringifyInlineTable");
+__name2(stringifyInlineTable, "stringifyInlineTable");
+function stringifyArray(array2, depth, numberAsFloat) {
+  if (array2.length === 0) return "[]";
+  let res = "[ ";
+  for (let i = 0; i < array2.length; i++) {
+    if (i) res += ", ";
+    if (array2[i] === null || array2[i] === void 0) throw new TypeError("arrays cannot contain null or undefined values");
+    res += stringifyValue(array2[i], extendedTypeOf(array2[i]), depth - 1, numberAsFloat);
+  }
+  return res + " ]";
+}
+__name(stringifyArray, "stringifyArray");
+__name2(stringifyArray, "stringifyArray");
+function stringifyArrayTable(array2, key, depth, numberAsFloat) {
+  if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+  let res = "";
+  for (let i = 0; i < array2.length; i++) {
+    res += `${res && "\n"}[[${key}]]
+`;
+    res += stringifyTable(0, array2[i], key, depth, numberAsFloat);
+  }
+  return res;
+}
+__name(stringifyArrayTable, "stringifyArrayTable");
+__name2(stringifyArrayTable, "stringifyArrayTable");
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+  if (depth === 0) throw new Error("Could not stringify the object: maximum object depth exceeded");
+  let preamble = "";
+  let tables = "";
+  let keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    let k = keys[i];
+    if (obj[k] !== null && obj[k] !== void 0) {
+      let type = extendedTypeOf(obj[k]);
+      if (type === "symbol" || type === "function") throw new TypeError(`cannot serialize values of type '${type}'`);
+      let key = BARE_KEY.test(k) ? k : formatString(k);
+      if (type === "array" && isArrayOfTables(obj[k])) tables += (tables && "\n") + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+      else if (type === "object") {
+        let tblKey = prefix ? `${prefix}.${key}` : key;
+        tables += (tables && "\n") + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+      } else {
+        preamble += key;
+        preamble += " = ";
+        preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+        preamble += "\n";
+      }
+    }
+  }
+  if (tableKey && (preamble || !tables)) preamble = preamble ? `[${tableKey}]
+${preamble}` : `[${tableKey}]`;
+  return preamble && tables ? `${preamble}
+${tables}` : preamble || tables;
+}
+__name(stringifyTable, "stringifyTable");
+__name2(stringifyTable, "stringifyTable");
+function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
+  if (extendedTypeOf(obj) !== "object") throw new TypeError("stringify can only be called with an object");
+  let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
+  if (str[str.length - 1] !== "\n") return str + "\n";
+  return str;
+}
+__name(stringify, "stringify");
+__name2(stringify, "stringify");
+var dist_default = {
+  parse: parse3,
+  stringify,
+  TomlDate,
+  TomlError
+};
+var ParseError = class extends UserError {
+  static {
+    __name(this, "ParseError");
+  }
+  static {
+    __name2(this, "ParseError");
+  }
+  text;
+  notes;
+  location;
+  kind;
+  constructor({ text, notes, location, kind, telemetryMessage }) {
+    super(text, { telemetryMessage });
+    this.name = this.constructor.name;
+    this.text = text;
+    this.notes = notes ?? [];
+    this.location = location;
+    this.kind = kind ?? "error";
+  }
+};
+(class extends ParseError {
+  static {
+    __name(this, "APIError");
+  }
+  static {
+    __name2(this, "APIError");
+  }
+  #status;
+  code;
+  accountTag;
+  constructor({ status, ...rest }) {
+    super(rest);
+    this.name = this.constructor.name;
+    this.#status = status;
+  }
+  get status() {
+    return this.#status;
+  }
+  isGatewayError() {
+    if (this.#status !== void 0) return [524].includes(this.#status);
+    return false;
+  }
+  isRetryable() {
+    return String(this.#status).startsWith("5");
+  }
+  #reportable = true;
+  get reportable() {
+    return this.#reportable;
+  }
+  preventReport() {
+    this.#reportable = false;
+  }
+});
+function parseTOML(tomlContent, filePath) {
+  try {
+    return dist_default.parse(tomlContent);
+  } catch (err) {
+    if (!(err instanceof TomlError)) throw err;
+    const location = {
+      lineText: tomlContent.split("\n")[err.line - 1],
+      line: err.line,
+      column: err.column - 1,
+      file: filePath,
+      fileText: tomlContent
+    };
+    throw new ParseError({
+      text: err.message.substring(0, err.message.indexOf("\n")),
+      location,
+      telemetryMessage: "TOML parse error"
+    });
+  }
+}
+__name(parseTOML, "parseTOML");
+__name2(parseTOML, "parseTOML");
+function parsePackageJSON(input, file2) {
+  return parseJSON(input, file2);
+}
+__name(parsePackageJSON, "parsePackageJSON");
+__name2(parsePackageJSON, "parsePackageJSON");
+function parseJSON(input, file2) {
+  return parseJSONC(input, file2, {
+    allowEmptyContent: false,
+    allowTrailingComma: false,
+    disallowComments: true
+  });
+}
+__name(parseJSON, "parseJSON");
+__name2(parseJSON, "parseJSON");
+function parseJSONC(input, file2, options = { allowTrailingComma: true }) {
+  const errors = [];
+  const data = parse2(input, errors, options);
+  if (errors.length) throw new ParseError({
+    text: printParseErrorCode(errors[0].error),
+    location: {
+      ...indexLocation({
+        file: file2,
+        fileText: input
+      }, errors[0].offset + 1),
+      length: errors[0].length
+    },
+    telemetryMessage: "JSON(C) parse error"
+  });
+  return data;
+}
+__name(parseJSONC, "parseJSONC");
+__name2(parseJSONC, "parseJSONC");
+function readFileSyncToBuffer(file2) {
+  try {
+    return readFileSync(file2);
+  } catch (err) {
+    const { message } = err;
+    throw new ParseError({
+      text: `Could not read file: ${file2}`,
+      notes: [{ text: message.replace(file2, resolve(file2)) }],
+      telemetryMessage: false
+    });
+  }
+}
+__name(readFileSyncToBuffer, "readFileSyncToBuffer");
+__name2(readFileSyncToBuffer, "readFileSyncToBuffer");
+function readFileSync$1(file2) {
+  try {
+    return removeBOMAndValidate(readFileSync(file2), file2);
+  } catch (err) {
+    if (err instanceof ParseError) throw err;
+    const { message } = err;
+    throw new ParseError({
+      text: `Could not read file: ${file2}`,
+      notes: [{ text: message.replace(file2, resolve(file2)) }],
+      telemetryMessage: "Could not read file"
+    });
+  }
+}
+__name(readFileSync$1, "readFileSync$1");
+__name2(readFileSync$1, "readFileSync");
+function indexLocation(file2, index) {
+  let lineText, line = 0, column = 0, cursor = 0;
+  const { fileText = "" } = file2;
+  for (const row of fileText.split("\n")) {
+    line++;
+    cursor += row.length + 1;
+    if (cursor >= index) {
+      lineText = row;
+      column = row.length - (cursor - index);
+      break;
+    }
+  }
+  return {
+    lineText,
+    line,
+    column,
+    ...file2
+  };
+}
+__name(indexLocation, "indexLocation");
+__name2(indexLocation, "indexLocation");
+function searchLocation(file2, query) {
+  let lineText, length, line = 0, column = 0;
+  const queryText = String(query);
+  const { fileText = "" } = file2;
+  for (const content of fileText.split("\n")) {
+    line++;
+    const index = content.indexOf(queryText);
+    if (index >= 0) {
+      lineText = content;
+      column = index;
+      length = queryText.length;
+      break;
+    }
+  }
+  return {
+    lineText,
+    line,
+    column,
+    length,
+    ...file2
+  };
+}
+__name(searchLocation, "searchLocation");
+__name2(searchLocation, "searchLocation");
+var units = {
+  nanoseconds: 1e-9,
+  nanosecond: 1e-9,
+  microseconds: 1e-6,
+  microsecond: 1e-6,
+  milliseconds: 1e-3,
+  millisecond: 1e-3,
+  seconds: 1,
+  second: 1,
+  minutes: 60,
+  minute: 60,
+  hours: 3600,
+  hour: 3600,
+  days: 86400,
+  day: 86400,
+  weeks: 604800,
+  week: 604800,
+  month: 18144e3,
+  year: 220752e3,
+  nsecs: 1e-9,
+  nsec: 1e-9,
+  usecs: 1e-6,
+  usec: 1e-6,
+  msecs: 1e-3,
+  msec: 1e-3,
+  secs: 1,
+  sec: 1,
+  mins: 60,
+  min: 60,
+  ns: 1e-9,
+  us: 1e-6,
+  ms: 1e-3,
+  mo: 18144e3,
+  yr: 220752e3,
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+  w: 604800,
+  y: 220752e3
+};
+function parseHumanDuration(s) {
+  const unitsMap = new Map(Object.entries(units));
+  s = s.trim().toLowerCase();
+  let base = 1;
+  for (const [name, _] of unitsMap) if (s.endsWith(name)) {
+    s = s.substring(0, s.length - name.length);
+    base = unitsMap.get(name) || 1;
+    break;
+  }
+  return Number(s) * base;
+}
+__name(parseHumanDuration, "parseHumanDuration");
+__name2(parseHumanDuration, "parseHumanDuration");
+function parseNonHyphenedUuid(uuid) {
+  if (uuid == null || uuid.includes("-")) return uuid;
+  if (uuid.length != 32) return null;
+  const uuid_parts = [];
+  uuid_parts.push(uuid.slice(0, 8));
+  uuid_parts.push(uuid.slice(8, 12));
+  uuid_parts.push(uuid.slice(12, 16));
+  uuid_parts.push(uuid.slice(16, 20));
+  uuid_parts.push(uuid.slice(20));
+  let hyphenated = "";
+  uuid_parts.forEach((part) => hyphenated += part + "-");
+  return hyphenated.slice(0, 36);
+}
+__name(parseNonHyphenedUuid, "parseNonHyphenedUuid");
+__name2(parseNonHyphenedUuid, "parseNonHyphenedUuid");
+function parseByteSize(s, base = void 0) {
+  const match = s.match(/^(\d*\.*\d*)\s*([kKmMgGtTpP]{0,1})([i]{0,1}[bB]{0,1})$/);
+  if (!match) return NaN;
+  const size = match[1];
+  if (size.length === 0 || isNaN(Number(size))) return NaN;
+  const unit = match[2].toLowerCase();
+  const sizeUnits = {
+    k: 1,
+    m: 2,
+    g: 3,
+    t: 4,
+    p: 5
+  };
+  if (unit.length !== 0 && !(unit in sizeUnits)) return NaN;
+  const binary = match[3].toLowerCase() == "ib";
+  if (binary && unit.length === 0) return NaN;
+  const pow = sizeUnits[unit] || 0;
+  return Math.floor(Number(size) * Math.pow(base ?? (binary ? 1024 : 1e3), pow));
+}
+__name(parseByteSize, "parseByteSize");
+__name2(parseByteSize, "parseByteSize");
+var UNSUPPORTED_BOMS = [
+  {
+    buffer: Buffer.from([
+      0,
+      0,
+      254,
+      255
+    ]),
+    encoding: "UTF-32 BE"
+  },
+  {
+    buffer: Buffer.from([
+      255,
+      254,
+      0,
+      0
+    ]),
+    encoding: "UTF-32 LE"
+  },
+  {
+    buffer: Buffer.from([254, 255]),
+    encoding: "UTF-16 BE"
+  },
+  {
+    buffer: Buffer.from([255, 254]),
+    encoding: "UTF-16 LE"
+  }
+];
+function removeBOMAndValidate(buffer, file2) {
+  for (const bom of UNSUPPORTED_BOMS) if (buffer.length >= bom.buffer.length && buffer.subarray(0, bom.buffer.length).equals(bom.buffer)) throw new ParseError({
+    text: `Configuration file contains ${bom.encoding} byte order marker`,
+    notes: [{ text: `The file "${file2}" appears to be encoded as ${bom.encoding}. Please save the file as UTF-8 without BOM.` }],
+    location: {
+      file: file2,
+      line: 1,
+      column: 0
+    },
+    telemetryMessage: `${bom.encoding} BOM detected`
+  });
+  const content = buffer.toString("utf-8");
+  if (content.charCodeAt(0) === 65279) return content.slice(1);
+  return content;
+}
+__name(removeBOMAndValidate, "removeBOMAndValidate");
+__name2(removeBOMAndValidate, "removeBOMAndValidate");
+var PATH_TO_DEPLOY_CONFIG = ".wrangler/deploy/config.json";
+function absolute(input, root) {
+  return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+__name(absolute, "absolute");
+__name2(absolute, "absolute");
+function up(base, options) {
+  let { last, cwd } = options || {};
+  let tmp = absolute(base, cwd);
+  let root = absolute(last || "/", cwd);
+  let prev, arr = [];
+  while (prev !== root) {
+    arr.push(tmp);
+    tmp = dirname(prev = tmp);
+    if (tmp === prev) break;
+  }
+  return arr;
+}
+__name(up, "up");
+__name2(up, "up");
+function file(name, options) {
+  let dir, tmp;
+  for (dir of up(options && options.cwd || "", options)) try {
+    tmp = join(dir, name);
+    if (statSync(tmp).isFile()) return tmp;
+  } catch {
+  }
+}
+__name(file, "file");
+__name2(file, "file");
+function dedent$2(templ) {
+  var values = [];
+  for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+  var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+  strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+  var indentLengths = strings.reduce(function(arr, str) {
+    var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+    if (matches) return arr.concat(matches.map(function(match) {
+      var _a, _b;
+      return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    }));
+    return arr;
+  }, []);
+  if (indentLengths.length) {
+    var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+    strings = strings.map(function(str) {
+      return str.replace(pattern_1, "\n");
+    });
+  }
+  strings[0] = strings[0].replace(/^\r?\n/, "");
+  var string2 = strings[0];
+  values.forEach(function(value, i) {
+    var endentations = string2.match(/(?:^|\n)( *)$/);
+    var endentation = endentations ? endentations[1] : "";
+    var indentedValue = value;
+    if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map(function(str, i2) {
+      return i2 === 0 ? str : "" + endentation + str;
+    }).join("\n");
+    string2 += indentedValue + strings[i + 1];
+  });
+  return string2;
+}
+__name(dedent$2, "dedent$2");
+__name2(dedent$2, "dedent");
+var esm_default = dedent$2;
+function resolveWranglerConfigPath({ config, script }, options) {
+  if (config !== void 0) return {
+    userConfigPath: config,
+    configPath: config,
+    deployConfigPath: void 0,
+    redirected: false
+  };
+  return findWranglerConfig(script !== void 0 ? path3__default.dirname(script) : process.cwd(), options);
+}
+__name(resolveWranglerConfigPath, "resolveWranglerConfigPath");
+__name2(resolveWranglerConfigPath, "resolveWranglerConfigPath");
+function findWranglerConfig(referencePath = process.cwd(), { useRedirectIfAvailable = false } = {}) {
+  const userConfigPath = file(`wrangler.json`, { cwd: referencePath }) ?? file(`wrangler.jsonc`, { cwd: referencePath }) ?? file(`wrangler.toml`, { cwd: referencePath });
+  if (!useRedirectIfAvailable) return {
+    userConfigPath,
+    configPath: userConfigPath,
+    deployConfigPath: void 0,
+    redirected: false
+  };
+  const { configPath, deployConfigPath, redirected } = findRedirectedWranglerConfig(referencePath, userConfigPath);
+  return {
+    userConfigPath,
+    configPath,
+    deployConfigPath,
+    redirected
+  };
+}
+__name(findWranglerConfig, "findWranglerConfig");
+__name2(findWranglerConfig, "findWranglerConfig");
+function findRedirectedWranglerConfig(cwd, userConfigPath) {
+  const deployConfigPath = file(PATH_TO_DEPLOY_CONFIG, { cwd });
+  if (deployConfigPath === void 0) return {
+    configPath: userConfigPath,
+    deployConfigPath,
+    redirected: false
+  };
+  let redirectedConfigPath;
+  const deployConfigFile = readFileSync$1(deployConfigPath);
+  try {
+    const deployConfig = parseJSONC(deployConfigFile, deployConfigPath);
+    redirectedConfigPath = deployConfig.configPath && path3__default.resolve(path3__default.dirname(deployConfigPath), deployConfig.configPath);
+  } catch (e) {
+    throw new UserError(`Failed to parse the deploy configuration file at ${path3__default.relative(".", deployConfigPath)}`, {
+      cause: e,
+      telemetryMessage: false
+    });
+  }
+  if (!redirectedConfigPath) throw new UserError(esm_default`
+			A deploy configuration file was found at "${path3__default.relative(".", deployConfigPath)}".
+			But this is not valid - the required "configPath" property was not found.
+			Instead this file contains:
+			\`\`\`
+			${deployConfigFile}
+			\`\`\`
+		`, { telemetryMessage: false });
+  if (!existsSync(redirectedConfigPath)) throw new UserError(esm_default`
+				There is a deploy configuration at "${path3__default.relative(".", deployConfigPath)}".
+				But the redirected configuration path it points to, "${path3__default.relative(".", redirectedConfigPath)}", does not exist.
+			`, { telemetryMessage: false });
+  if (userConfigPath) {
+    if (path3__default.join(path3__default.dirname(userConfigPath), PATH_TO_DEPLOY_CONFIG) !== deployConfigPath) throw new UserError(esm_default`
+					Found both a user configuration file at "${path3__default.relative(".", userConfigPath)}"
+					and a deploy configuration file at "${path3__default.relative(".", deployConfigPath)}".
+					But these do not share the same base path so it is not clear which should be used.
+				`, { telemetryMessage: false });
+  }
+  return {
+    configPath: redirectedConfigPath,
+    deployConfigPath,
+    redirected: true
+  };
+}
+__name(findRedirectedWranglerConfig, "findRedirectedWranglerConfig");
+__name2(findRedirectedWranglerConfig, "findRedirectedWranglerConfig");
+function isRedirectedConfig(config) {
+  return config.configPath !== void 0 && config.configPath !== config.userConfigPath;
+}
+__name(isRedirectedConfig, "isRedirectedConfig");
+__name2(isRedirectedConfig, "isRedirectedConfig");
+function isRedirectedRawConfig(rawConfig, configPath, userConfigPath) {
+  return isRedirectedConfig({
+    configPath,
+    userConfigPath
+  });
+}
+__name(isRedirectedRawConfig, "isRedirectedRawConfig");
+__name2(isRedirectedRawConfig, "isRedirectedRawConfig");
+function configFormat(configPath) {
+  if (configPath?.endsWith("toml")) return "toml";
+  if (configPath?.endsWith("jsonc")) return "jsonc";
+  if (configPath?.endsWith("json")) return "json";
+  return "none";
+}
+__name(configFormat, "configFormat");
+__name2(configFormat, "configFormat");
+function configFileName(configPath) {
+  switch (configFormat(configPath)) {
+    case "toml":
+      return "wrangler.toml";
+    case "json":
+      return "wrangler.json";
+    case "jsonc":
+      return "wrangler.jsonc";
+    default:
+      return "Wrangler configuration";
+  }
+}
+__name(configFileName, "configFileName");
+__name2(configFileName, "configFileName");
+function formatConfigSnippet(snippet, configPath, formatted = true) {
+  if (configFormat(configPath) === "toml") return dist_default.stringify(snippet);
+  else return formatted ? JSON.stringify(snippet, null, 2) : JSON.stringify(snippet);
+}
+__name(formatConfigSnippet, "formatConfigSnippet");
+__name2(formatConfigSnippet, "formatConfigSnippet");
+function isDirectory(path22) {
+  return fs2.statSync(path22, { throwIfNoEntry: false })?.isDirectory() ?? false;
+}
+__name(isDirectory, "isDirectory");
+__name2(isDirectory, "isDirectory");
+function removeDir(dirPath, { fireAndForget = false } = {}) {
+  const result = fs2.promises.rm(dirPath, {
+    recursive: true,
+    force: true,
+    maxRetries: 5,
+    retryDelay: 100
+  });
+  if (fireAndForget) result.catch(() => {
+  });
+  else return result;
+}
+__name(removeDir, "removeDir");
+__name2(removeDir, "removeDir");
+function removeDirSync(dirPath) {
+  fs2.rmSync(dirPath, {
+    recursive: true,
+    force: true,
+    maxRetries: 5,
+    retryDelay: 100
+  });
+}
+__name(removeDirSync, "removeDirSync");
+__name2(removeDirSync, "removeDirSync");
 var AssetsSchema = z.strictObject({
   htmlHandling: z.enum([
     "auto-trailing-slash",
@@ -3091,7 +5717,7 @@ var ModuleTypeSchema = z.enum([
   "esm",
   "cjs",
   "python",
-  "pythonRequirement",
+  "python-requirement",
   "wasm",
   "text",
   "data",
@@ -3780,10 +6406,10 @@ var UpdateApplicationRolloutRequest;
 // ../containers-shared/src/utils.ts
 var runDockerCmd = /* @__PURE__ */ __name((dockerPath, args, stdio) => {
   let aborted = false;
-  let resolve3;
+  let resolve4;
   let reject;
   const ready = new Promise((res, rej) => {
-    resolve3 = res;
+    resolve4 = res;
     reject = rej;
   });
   const child = spawn(dockerPath, args, {
@@ -3801,11 +6427,11 @@ var runDockerCmd = /* @__PURE__ */ __name((dockerPath, args, stdio) => {
   let errorHandled = false;
   child.on("close", (code) => {
     if (code === 0 || aborted) {
-      resolve3({ aborted });
+      resolve4({ aborted });
     } else if (!errorHandled) {
       errorHandled = true;
       reject(
-        new UserError(`Docker command exited with code: ${code}`, {
+        new UserError$1(`Docker command exited with code: ${code}`, {
           telemetryMessage: false
         })
       );
@@ -3815,7 +6441,7 @@ var runDockerCmd = /* @__PURE__ */ __name((dockerPath, args, stdio) => {
     if (!errorHandled) {
       errorHandled = true;
       reject(
-        new UserError(`Docker command failed: ${err.message}`, {
+        new UserError$1(`Docker command failed: ${err.message}`, {
           telemetryMessage: false
         })
       );
@@ -3853,7 +6479,7 @@ var verifyDockerInstalled = /* @__PURE__ */ __name(async ({
 }) => {
   const dockerIsRunning = await isDockerRunning(dockerPath);
   if (!dockerIsRunning) {
-    throw new UserError(
+    throw new UserError$1(
       getFailedToRunDockerErrorMessage({
         numberOfContainers,
         isDev,
@@ -3945,7 +6571,7 @@ async function getZoneIdFromHost(complianceConfig, from, zoneIdCache = /* @__PUR
     }
     hostPieces.shift();
   }
-  throw new UserError(
+  throw new UserError$1(
     `Could not find zone for \`${from.host}\`. Make sure the domain is set up to be proxied by Cloudflare.
 For more details, refer to https://developers.cloudflare.com/workers/configuration/routing/routes/#set-up-a-route`,
     { telemetryMessage: "zones route zone not found" }
@@ -3993,7 +6619,7 @@ function renderRoute(route) {
 }
 __name(renderRoute, "renderRoute");
 function isAuthenticationError(e) {
-  return e instanceof ParseError && e.code === 1e4;
+  return e instanceof ParseError$1 && e.code === 1e4;
 }
 __name(isAuthenticationError, "isAuthenticationError");
 async function publishRoutes(complianceConfig, routes, {
@@ -4034,7 +6660,7 @@ async function publishRoutesFallback(complianceConfig, routes, {
   accountId
 }) {
   if (useServiceEnvironments2) {
-    throw new UserError(
+    throw new UserError$1(
       "Service environments combined with an API token that doesn't have 'All Zones' permissions is not supported.\nEither turn off service environments by setting `legacy_env = true`, creating an API token with 'All Zones' permissions, or logging in via OAuth",
       {
         telemetryMessage: "deploy service environments require all zones permission"
@@ -4100,7 +6726,7 @@ async function publishRoutesFallback(complianceConfig, routes, {
         alreadyDeployedRoutes.delete(routePattern);
         continue;
       } else {
-        throw new UserError(
+        throw new UserError$1(
           `The route with pattern "${routePattern}" is already associated with another worker called "${knownScript}".`,
           { telemetryMessage: "route already associated with another worker" }
         );
@@ -4149,7 +6775,7 @@ async function publishCustomDomains(complianceConfig, workerUrl, accountId, doma
   const fail = /* @__PURE__ */ __name(() => {
     return {
       targets: [],
-      error: new UserError(
+      error: new UserError$1(
         domains.length > 1 ? `Publishing to ${domains.length} Custom Domains was skipped, fix conflicts and try again` : `Publishing to Custom Domain "${domains[0].pattern}" was skipped, fix conflict and try again`,
         { telemetryMessage: "deploy custom domains skipped" }
       )
@@ -4231,7 +6857,7 @@ __name(listQueues, "listQueues");
 async function getQueue(complianceConfig, accountId, queueName) {
   const queues = await listQueues(complianceConfig, accountId, 1, queueName);
   if (queues.length === 0) {
-    throw new UserError(
+    throw new UserError$1(
       `Queue "${queueName}" does not exist. To create it, run: wrangler queues create ${queueName}`,
       { telemetryMessage: "queues lookup missing queue" }
     );
@@ -4290,7 +6916,7 @@ async function resolveWorkerConsumerByName(complianceConfig, accountId, consumer
     (c) => c.type === "worker" && (c.script === consumerName || c.service === consumerName)
   );
   if (consumers.length === 0) {
-    throw new UserError(
+    throw new UserError$1(
       `No worker consumer '${consumerName}' exists for queue ${queue.queue_name}`,
       { telemetryMessage: "queues worker consumer missing" }
     );
@@ -4301,7 +6927,7 @@ async function resolveWorkerConsumerByName(complianceConfig, accountId, consumer
       (c) => c.environment === targetEnv
     );
     if (targetConsumers.length === 0) {
-      throw new UserError(
+      throw new UserError$1(
         `No worker consumer '${consumerName}' exists for queue ${queueName}`,
         { telemetryMessage: "queues worker consumer missing environment" }
       );
@@ -4311,7 +6937,7 @@ async function resolveWorkerConsumerByName(complianceConfig, accountId, consumer
   if (consumers[0].service) {
     const targetEnv = envName ?? await getDefaultService(complianceConfig, accountId, consumerName);
     if (targetEnv != consumers[0].environment) {
-      throw new UserError(
+      throw new UserError$1(
         `No worker consumer '${consumerName}' exists for queue ${queueName}`,
         { telemetryMessage: "queues worker consumer environment mismatch" }
       );
@@ -4346,7 +6972,7 @@ async function deletePullConsumer(complianceConfig, accountId, queueName) {
   const queue = await getQueue(complianceConfig, accountId, queueName);
   const consumer = queue.consumers[0];
   if (consumer?.type !== "http_pull") {
-    throw new UserError(`No http_pull consumer exists for queue ${queueName}`, {
+    throw new UserError$1(`No http_pull consumer exists for queue ${queueName}`, {
       telemetryMessage: "queues http pull consumer missing"
     });
   }
@@ -4459,7 +7085,7 @@ async function ensureQueuesExistByConfig(config, accountId) {
       const queueSet = new Set(existingQueues);
       for (const queue of queueNames) {
         if (!queueSet.has(queue)) {
-          throw new UserError(
+          throw new UserError$1(
             `Queue "${queue}" does not exist. To create it, run: wrangler queues create ${queue}`,
             { telemetryMessage: "queues config missing queue" }
           );
@@ -4527,7 +7153,7 @@ function getRegistrationDeclinedError(registrationContext, accountId, configPath
   const onboardingLink = `https://dash.cloudflare.com/${accountId}/workers/onboarding`;
   switch (registrationContext) {
     case "workflows":
-      return new UserError(
+      return new UserError$1(
         `Workflows require your account to have a workers.dev subdomain. Register a workers.dev subdomain here:
 ${onboardingLink}`,
         {
@@ -4535,8 +7161,8 @@ ${onboardingLink}`,
         }
       );
     case "workers_dev": {
-      const solutionMessage = `You can either deploy your worker to one or more routes by specifying them in your ${configFileName(configPath)} file, or register a workers.dev subdomain here:`;
-      return new UserError(`${solutionMessage}
+      const solutionMessage = `You can either deploy your worker to one or more routes by specifying them in your ${configFileName$1(configPath)} file, or register a workers.dev subdomain here:`;
+      return new UserError$1(`${solutionMessage}
 ${onboardingLink}`, {
         telemetryMessage: "routes workers dev registration declined"
       });
@@ -4714,7 +7340,7 @@ ${assignedRoutes.map(
         `https://dash.cloudflare.com/${accountId}/workers/overview`
       );
       const dashLink = `Visit ${dashHref} to unassign a worker from a route.`;
-      throw new UserError(`${errorMessage}
+      throw new UserError$1(`${errorMessage}
 ${resolution}
 ${dashLink}`, {
         telemetryMessage: "triggers deploy routes assigned"
@@ -4794,7 +7420,7 @@ ${dashLink}`, {
     for (const workflow of config.workflows) {
       if (!isWorkflowDefinedInThisScript(workflow, scriptName)) {
         if (workflow.limits) {
-          throw new UserError(
+          throw new UserError$1(
             `Workflow "${workflow.name}" has "limits" configured but references external script "${workflow.script_name}". Configure limits on the worker that defines the workflow.`,
             {
               telemetryMessage: "triggers deploy workflow limits external script"
@@ -4802,7 +7428,7 @@ ${dashLink}`, {
           );
         }
         if (workflow.schedules) {
-          throw new UserError(
+          throw new UserError$1(
             `Workflow "${workflow.name}" has "schedules" configured but references external script "${workflow.script_name}". Configure schedules on the worker that defines the workflow.`,
             {
               telemetryMessage: "triggers deploy workflow schedules external script"
@@ -4853,7 +7479,7 @@ ${dashLink}`, {
   }
   const errors = completedDeployments.map((deployment) => deployment.error).filter((error) => error !== void 0);
   if (errors.length > 0) {
-    throw new UserError(
+    throw new UserError$1(
       `Some triggers failed to deploy for ${workerName}:
 ` + errors.map((error) => `  - ${error.message}`).join("\n"),
       {
@@ -4872,7 +7498,7 @@ ${dashLink}`, {
 __name(triggersDeploy, "triggersDeploy");
 function aggregateTelemetryMessages(errors) {
   const labels = errors.map(
-    (error) => error instanceof UserError && error.telemetryMessage ? error.telemetryMessage : "non-user error"
+    (error) => error instanceof UserError$1 && error.telemetryMessage ? error.telemetryMessage : "non-user error"
   );
   return Array.from(new Set(labels)).sort().join(", ");
 }
@@ -6247,12 +8873,12 @@ var Mime = class {
     }
     return this;
   }
-  getType(path8) {
-    if (typeof path8 !== "string")
+  getType(path9) {
+    if (typeof path9 !== "string")
       return null;
-    const last = path8.replace(/^.*[/\\]/s, "").toLowerCase();
+    const last = path9.replace(/^.*[/\\]/s, "").toLowerCase();
     const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path8.length;
+    const hasPath = last.length < path9.length;
     const hasDot = ext.length < last.length - 1;
     if (!hasDot && hasPath)
       return null;
@@ -6392,14 +9018,14 @@ var syncAssets = /* @__PURE__ */ __name(async (complianceConfig, accountId, asse
     body: JSON.stringify({ manifest })
   });
   if (!initializeAssetsResponse) {
-    throw new FatalError(
+    throw new FatalError$1(
       "An unexpected response has been received from the Cloudflare API for assets upload. Please try again.",
       { code: 1, telemetryMessage: "assets upload unexpected api response" }
     );
   }
   if (initializeAssetsResponse.buckets.flat().length === 0) {
     if (!initializeAssetsResponse.jwt) {
-      throw new FatalError(
+      throw new FatalError$1(
         "Could not find assets information to attach to deployment. Please try again.",
         { code: 1, telemetryMessage: "assets upload missing completion token" }
       );
@@ -6418,10 +9044,10 @@ var syncAssets = /* @__PURE__ */ __name(async (complianceConfig, accountId, asse
   const assetBuckets = initializeAssetsResponse.buckets.map((bucket) => {
     return bucket.map((fileHash) => {
       const manifestEntry = manifestLookup.find(
-        (file) => file[1].hash === fileHash
+        (file2) => file2[1].hash === fileHash
       );
       if (manifestEntry === void 0) {
-        throw new FatalError(
+        throw new FatalError$1(
           `A file was requested that does not appear to exist.`,
           {
             code: 1,
@@ -6446,7 +9072,7 @@ var syncAssets = /* @__PURE__ */ __name(async (complianceConfig, accountId, asse
       const payload = new FormData();
       const uploadedFiles = [];
       for (const manifestEntry of bucket) {
-        const absFilePath = path.join(assetDirectory, manifestEntry[0]);
+        const absFilePath = path3.join(assetDirectory, manifestEntry[0]);
         uploadedFiles.push(manifestEntry[0]);
         payload.append(
           manifestEntry[1].hash,
@@ -6509,7 +9135,7 @@ var syncAssets = /* @__PURE__ */ __name(async (complianceConfig, accountId, asse
           }
           return doUpload();
         } else if (isJwtExpired(initializeAssetsResponse.jwt)) {
-          throw new FatalError(
+          throw new FatalError$1(
             `Upload took too long.
 Asset upload took too long on bucket ${bucketIndex + 1}/${initializeAssetsResponse.buckets.length}. Please try again.
 Assets already uploaded have been saved, so the next attempt will automatically resume from this point.`,
@@ -6534,7 +9160,7 @@ Assets already uploaded have been saved, so the next attempt will automatically
   });
   await Promise.all(queuePromises);
   if (!completionJwt) {
-    throw new FatalError("Failed to complete asset upload. Please try again.", {
+    throw new FatalError$1("Failed to complete asset upload. Please try again.", {
       code: 1,
       telemetryMessage: "assets upload completion failed"
     });
@@ -6559,7 +9185,7 @@ var buildAssetManifest = /* @__PURE__ */ __name(async (dir) => {
         logger.debug("Ignoring asset:", relativeFilepath);
         return;
       }
-      const filepath = path.join(dir, relativeFilepath);
+      const filepath = path3.join(dir, relativeFilepath);
       const filestat = await stat(filepath);
       if (filestat.isSymbolicLink() || filestat.isDirectory()) {
         return;
@@ -6569,7 +9195,7 @@ var buildAssetManifest = /* @__PURE__ */ __name(async (dir) => {
           assetsIgnoreFilePresent
         );
         if (filestat.size > MAX_ASSET_SIZE) {
-          throw new UserError(
+          throw new UserError$1(
             `Asset too large.
 Cloudflare Workers supports assets with sizes of up to ${prettyBytes(
               MAX_ASSET_SIZE,
@@ -6612,22 +9238,22 @@ function logAssetsUploadStatus(numberFilesToUpload, uploadedAssetsCount, uploade
   logger.info(
     `Uploaded ${uploadedAssetsCount} of ${numberFilesToUpload} asset${numberFilesToUpload === 1 ? "" : "s"}`
   );
-  uploadedAssetFiles.forEach((file) => logger.debug(`\u2728 ${file}`));
+  uploadedAssetFiles.forEach((file2) => logger.debug(`\u2728 ${file2}`));
 }
 __name(logAssetsUploadStatus, "logAssetsUploadStatus");
 function logReadFilesFromDirectory(directory, assetFiles) {
   logger.info(
     `\u2728 Read ${assetFiles.length} file${assetFiles.length === 1 ? "" : "s"} from the assets directory ${directory}`
   );
-  assetFiles.forEach((file) => logger.debug(`/${file}`));
+  assetFiles.forEach((file2) => logger.debug(`/${file2}`));
 }
 __name(logReadFilesFromDirectory, "logReadFilesFromDirectory");
 var WORKER_JS_FILENAME = "_worker.js";
-function errorOnLegacyPagesWorkerJSAsset(file, hasAssetsIgnoreFile) {
+function errorOnLegacyPagesWorkerJSAsset(file2, hasAssetsIgnoreFile) {
   if (!hasAssetsIgnoreFile) {
-    const workerJsType = file === WORKER_JS_FILENAME ? "file" : file.startsWith(WORKER_JS_FILENAME) ? "directory" : null;
+    const workerJsType = file2 === WORKER_JS_FILENAME ? "file" : file2.startsWith(WORKER_JS_FILENAME) ? "directory" : null;
     if (workerJsType !== null) {
-      throw new UserError(
+      throw new UserError$1(
         `
 Uploading a Pages ${WORKER_JS_FILENAME} ${workerJsType} as an asset.
 This could expose your private server-side code to the public Internet. Is this intended?
@@ -6661,13 +9287,13 @@ function resolveAssetOptions({ assetsDir, main }, config) {
     );
   }
   if (!routerConfig.has_user_worker && (routerConfig.invoke_user_worker_ahead_of_assets === true || routerConfig.static_routing)) {
-    throw new UserError(
+    throw new UserError$1(
       "Cannot set run_worker_first without a Worker script.\nPlease remove run_worker_first from your configuration file, or provide a Worker script in your configuration file (`main`).",
       { telemetryMessage: "assets router missing worker script" }
     );
   }
-  const _redirects = directoryExists ? maybeGetFile(path.join(directory, REDIRECTS_FILENAME)) : void 0;
-  const _headers = directoryExists ? maybeGetFile(path.join(directory, HEADERS_FILENAME)) : void 0;
+  const _redirects = directoryExists ? maybeGetFile(path3.join(directory, REDIRECTS_FILENAME)) : void 0;
+  const _headers = directoryExists ? maybeGetFile(path3.join(directory, HEADERS_FILENAME)) : void 0;
   const assetConfig = {
     html_handling: config.assets?.html_handling,
     not_found_handling: config.assets?.not_found_handling,
@@ -7032,9 +9658,9 @@ var ONE_KIB_BYTES = 1024;
 var MAX_GZIP_SIZE_BYTES = 3 * ONE_KIB_BYTES * ONE_KIB_BYTES;
 async function getSize(modules) {
   const gzipSize = gzipSync(
-    await new Blob(modules.map((file) => file.content)).arrayBuffer()
+    await new Blob(modules.map((file2) => file2.content)).arrayBuffer()
   ).byteLength;
-  const aggregateSize = new Blob(modules.map((file) => file.content)).size;
+  const aggregateSize = new Blob(modules.map((file2) => file2.content)).size;
   return { size: aggregateSize, gzipSize };
 }
 __name(getSize, "getSize");
@@ -7917,7 +10543,7 @@ function handleUnsafeCapnp(capnp) {
     (x) => resolve(base_path, x)
   );
   if (!sync("capnp")) {
-    throw new UserError(
+    throw new UserError$1(
       "The capnp compiler is required to upload capnp schemas, but is not present.",
       { telemetryMessage: "capnp compiler missing" }
     );
@@ -8094,7 +10720,7 @@ function createWorkerUploadForm(worker, bindings, options) {
       id ??= INHERIT_SYMBOL;
     }
     if (id === void 0) {
-      throw new UserError(`${binding} bindings must have an "id" field`, {
+      throw new UserError$1(`${binding} bindings must have an "id" field`, {
         telemetryMessage: "kv namespace binding missing id"
       });
     }
@@ -8157,7 +10783,7 @@ function createWorkerUploadForm(worker, bindings, options) {
       bucket_name ??= INHERIT_SYMBOL;
     }
     if (bucket_name === void 0) {
-      throw new UserError(
+      throw new UserError$1(
         `${binding} bindings must have a "bucket_name" field`,
         { telemetryMessage: "r2 bucket binding missing bucket_name" }
       );
@@ -8183,7 +10809,7 @@ function createWorkerUploadForm(worker, bindings, options) {
         database_id ??= INHERIT_SYMBOL;
       }
       if (database_id === void 0) {
-        throw new UserError(
+        throw new UserError$1(
           `${binding} bindings must have a "database_id" field`,
           { telemetryMessage: "d1 database binding missing database_id" }
         );
@@ -8217,7 +10843,7 @@ function createWorkerUploadForm(worker, bindings, options) {
       namespace ??= INHERIT_SYMBOL;
     }
     if (namespace === void 0) {
-      throw new UserError(`${binding} bindings must have a "namespace" field`, {
+      throw new UserError$1(`${binding} bindings must have a "namespace" field`, {
         telemetryMessage: "ai search namespace binding missing namespace"
       });
     }
@@ -8252,7 +10878,7 @@ function createWorkerUploadForm(worker, bindings, options) {
       namespace ??= INHERIT_SYMBOL;
     }
     if (namespace === void 0) {
-      throw new UserError(`${binding} bindings must have a "namespace" field`, {
+      throw new UserError$1(`${binding} bindings must have a "namespace" field`, {
         telemetryMessage: false
       });
     }
@@ -8526,14 +11152,14 @@ function createWorkerUploadForm(worker, bindings, options) {
   if (hasManifest && main.type === "esm") {
     assert6(modules !== void 0);
     const subDirs = new Set(
-      modules.map((module) => path__default.posix.dirname(module.name))
+      modules.map((module) => path3__default.posix.dirname(module.name))
     );
     for (const subDir of subDirs) {
       if (subDir === ".") {
         continue;
       }
-      const relativePath = path__default.posix.relative(subDir, manifestModuleName);
-      const filePath = path__default.posix.join(subDir, manifestModuleName);
+      const relativePath = path3__default.posix.relative(subDir, manifestModuleName);
+      const filePath = path3__default.posix.join(subDir, manifestModuleName);
       modules.push({
         name: filePath,
         filePath,
@@ -8803,7 +11429,7 @@ async function getMigrationsToUpload(scriptName, props) {
       );
       if (foundIndex === -1) {
         logger.warn(
-          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in your ${configFileName(config.configPath)} file. You may have already deleted it. Applying all available migrations to the script...`
+          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in your ${configFileName$1(config.configPath)} file. You may have already deleted it. Applying all available migrations to the script...`
         );
         migrations = {
           old_tag: script.migration_tag,
@@ -8912,7 +11538,7 @@ function dedent(templ) {
   return string2;
 }
 __name(dedent, "dedent");
-var esm_default = dedent;
+var esm_default2 = dedent;
 
 // src/deploy/helpers/friendly-validator-errors.ts
 async function helpIfErrorIsSizeOrScriptStartup(err, dependencies, workerBundle, projectRoot, analyseBundle) {
@@ -8931,7 +11557,7 @@ async function helpIfErrorIsSizeOrScriptStartup(err, dependencies, workerBundle,
 }
 __name(helpIfErrorIsSizeOrScriptStartup, "helpIfErrorIsSizeOrScriptStartup");
 function diagnoseScriptSizeError(err, dependencies) {
-  let message = esm_default`
+  let message = esm_default2`
 		Your Worker failed validation because it exceeded size limits.
 
 		${err.text}
@@ -8945,7 +11571,7 @@ function diagnoseScriptSizeError(err, dependencies) {
 }
 __name(diagnoseScriptSizeError, "diagnoseScriptSizeError");
 async function diagnoseStartupError(err, workerBundle, projectRoot, analyseBundle) {
-  let errorMessage = esm_default`
+  let errorMessage = esm_default2`
 		Your Worker failed validation because it exceeded startup limits.
 
 		${err.text}
@@ -8964,12 +11590,12 @@ async function diagnoseStartupError(err, workerBundle, projectRoot, analyseBundl
       "startup-profile",
       false
     );
-    const profile = path__default.relative(
+    const profile = path3__default.relative(
       projectRoot ?? process.cwd(),
-      path__default.join(tmpDir.path, `worker.cpuprofile`)
+      path3__default.join(tmpDir.path, `worker.cpuprofile`)
     );
     await writeFile(profile, JSON.stringify(cpuProfile));
-    errorMessage += esm_default`
+    errorMessage += esm_default2`
 
 			A CPU Profile of your Worker's startup phase has been written to ${profile} - load it into the Chrome DevTools profiler (or directly in VSCode) to view a flamegraph.`;
   } catch (profilingError) {
@@ -9004,7 +11630,7 @@ function getOffendingDependenciesMessage(dependencies) {
 }
 __name(getOffendingDependenciesMessage, "getOffendingDependenciesMessage");
 function errIsScriptSize(err) {
-  if (!(err instanceof ParseError)) {
+  if (!(err instanceof ParseError$1)) {
     return false;
   }
   if ("code" in err && err.code === 10027) {
@@ -9014,7 +11640,7 @@ function errIsScriptSize(err) {
 }
 __name(errIsScriptSize, "errIsScriptSize");
 function errIsStartupErr(err) {
-  if (!(err instanceof ParseError)) {
+  if (!(err instanceof ParseError$1)) {
     return false;
   }
   if ("code" in err && err.code === 10021 && /startup/i.test(err.notes[0]?.text)) {
@@ -9040,8 +11666,8 @@ async function verifyWorkerMatchesCITag(complianceConfig, accountId, workerName,
   }
   const envAccountID = getCloudflareAccountIdFromEnv();
   if (accountId !== envAccountID) {
-    throw new FatalError(
-      `The \`account_id\` in your ${configFileName(configPath)} file must match the \`account_id\` for this account. Please update your ${configFileName(configPath)} file with \`${formatConfigSnippet({ account_id: envAccountID }, configPath, false)}\``,
+    throw new FatalError$1(
+      `The \`account_id\` in your ${configFileName$1(configPath)} file must match the \`account_id\` for this account. Please update your ${configFileName$1(configPath)} file with \`${formatConfigSnippet$1({ account_id: envAccountID }, configPath, false)}\``,
       { telemetryMessage: "ci match tag account mismatch" }
     );
   }
@@ -9056,17 +11682,17 @@ async function verifyWorkerMatchesCITag(complianceConfig, accountId, workerName,
   } catch (e) {
     logger.debug(e);
     if (isWorkerNotFoundError(e)) {
-      throw new FatalError(
-        `The name in your ${configFileName(configPath)} file (${workerName}) must match the name of your Worker. Please update the name field in your ${configFileName(configPath)} file.`,
+      throw new FatalError$1(
+        `The name in your ${configFileName$1(configPath)} file (${workerName}) must match the name of your Worker. Please update the name field in your ${configFileName$1(configPath)} file.`,
         { telemetryMessage: "ci match tag worker not found" }
       );
     } else if (e instanceof APIError) {
-      throw new FatalError(
+      throw new FatalError$1(
         "An error occurred while trying to validate that the Worker name matches what is expected by the build system.\n" + e.message + "\n" + e.notes.map((note) => note.text).join("\n"),
         { telemetryMessage: "ci match tag validation api error" }
       );
     } else {
-      throw new FatalError(
+      throw new FatalError$1(
         "Wrangler cannot validate that your Worker name matches what is expected by the build system. Please retry the build. If the problem persists, please contact support.",
         { telemetryMessage: "ci match tag validation failed" }
       );
@@ -9076,8 +11702,8 @@ async function verifyWorkerMatchesCITag(complianceConfig, accountId, workerName,
     logger.debug(
       `Failed to match Worker tag. The API returned "${tag}", but the CI system expected "${matchTag}"`
     );
-    throw new FatalError(
-      `The name in your ${configFileName(configPath)} file (${workerName}) must match the name of your Worker. Please update the name field in your ${configFileName(configPath)} file.`,
+    throw new FatalError$1(
+      `The name in your ${configFileName$1(configPath)} file (${workerName}) must match the name of your Worker. Please update the name field in your ${configFileName$1(configPath)} file.`,
       { telemetryMessage: "ci match tag tag mismatch" }
     );
   }
@@ -9085,7 +11711,7 @@ async function verifyWorkerMatchesCITag(complianceConfig, accountId, workerName,
 __name(verifyWorkerMatchesCITag, "verifyWorkerMatchesCITag");
 function validateFileSecrets(content, jsonFilePath) {
   if (content === null || typeof content !== "object") {
-    throw new FatalError(
+    throw new FatalError$1(
       `The contents of "${jsonFilePath}" is not valid. It should be a JSON object of string values.`,
       { telemetryMessage: "secret bulk file invalid contents" }
     );
@@ -9093,7 +11719,7 @@ function validateFileSecrets(content, jsonFilePath) {
   const entries = Object.entries(content);
   for (const [key, value] of entries) {
     if (value != null && typeof value !== "string") {
-      throw new FatalError(
+      throw new FatalError$1(
         `The value for "${key}" in "${jsonFilePath}" is not null or a "string" instead it is of type "${typeof value}"`,
         { telemetryMessage: "secret bulk file invalid value type" }
       );
@@ -9117,16 +11743,16 @@ async function parseBulkInputToObject(input, includeNull = false) {
   let secretFormat;
   if (input) {
     secretSource = "file";
-    const jsonFilePath = path__default.resolve(input);
-    const fileContent = readFileSync$1(jsonFilePath);
+    const jsonFilePath = path3__default.resolve(input);
+    const fileContent = readFileSync$2(jsonFilePath);
     try {
-      content = parseJSON(fileContent);
+      content = parseJSON$1(fileContent);
       secretFormat = "json";
     } catch {
-      content = parse(fileContent);
+      content = parse$1(fileContent);
       secretFormat = "dotenv";
       if (Object.keys(content).length === 0) {
-        throw new UserError(`The contents of "${input}" is not valid.`, {
+        throw new UserError$1(`The contents of "${input}" is not valid.`, {
           telemetryMessage: "secret bulk invalid input"
         });
       }
@@ -9141,10 +11767,10 @@ async function parseBulkInputToObject(input, includeNull = false) {
       }
       const pipedInput = pipedInputLines.join("\n");
       try {
-        content = parseJSON(pipedInput);
+        content = parseJSON$1(pipedInput);
         secretFormat = "json";
       } catch (e) {
-        content = parse(pipedInput);
+        content = parse$1(pipedInput);
         secretFormat = "dotenv";
         if (Object.keys(content).length === 0) {
           throw e;
@@ -9581,13 +12207,15 @@ function printBindings(bindings, tailConsumers = [], streamingTailConsumers = []
   }
   if (services.length > 0) {
     output.push(
-      ...services.map(({ binding, service, entrypoint, remote }) => {
+      ...services.map(({ binding, service, entrypoint, remote, dev }) => {
         let value = service;
         let mode = void 0;
         if (entrypoint) {
           value += `#${entrypoint}`;
         }
-        if (remote) {
+        if (dev !== void 0 && context.local) {
+          mode = getMode({ isSimulatedLocally: true });
+        } else if (remote) {
           mode = getMode({ isSimulatedLocally: false });
         } else if (context.local && context.registry !== null) {
           const isSelfBinding = service === context.name;
@@ -9979,7 +12607,7 @@ function warnOrError(type, remote) {
       return;
     case "local-only":
       if (remote === true) {
-        throw new UserError(
+        throw new UserError$1(
           `${getBindingTypeFriendlyName(type)} bindings do not support accessing remote resources.`,
           {
             telemetryMessage: "utils bindings unsupported remote resources"
@@ -9989,7 +12617,7 @@ function warnOrError(type, remote) {
       return;
     case "remote":
       if (remote === false) {
-        throw new UserError(
+        throw new UserError$1(
           `${getBindingTypeFriendlyName(type)} bindings do not support local development. You can set \`remote: true\` for the binding definition in your configuration file to access a remote version of the resource.`,
           {
             telemetryMessage: "utils bindings unsupported local development"
@@ -10004,7 +12632,7 @@ function warnOrError(type, remote) {
       return;
     case "DO-NOT-USE-this-resource-will-never-have-a-local-simulator":
       if (remote === false) {
-        throw new UserError(
+        throw new UserError$1(
           `${getBindingTypeFriendlyName(type)} bindings do not support local development. You can set \`remote: true\` for the binding definition in your configuration file to access a remote version of the resource.`,
           {
             telemetryMessage: "utils bindings unsupported local development always remote"
@@ -10038,7 +12666,7 @@ function addRequiredSecretsInheritBindings(config, bindings, options) {
     return;
   }
   if (options.type === "deploy" && !options.workerExists) {
-    throw new UserError(
+    throw new UserError$1(
       `The following required secrets have not been set: ${inheritedSecrets.join(", ")}
 Use \`wrangler secret put <NAME>\` to set secrets before deploying.
 See https://developers.cloudflare.com/workers/configuration/secrets/#secrets-on-deployed-workers for more information.`,
@@ -10057,7 +12685,7 @@ function handleMissingSecretsError(err, config, options) {
   const missingSecretNames = err.notes.map((note) => note.text.match(/^inherit binding '(.+?)' is invalid/)).filter((match) => match !== null).map((match) => match[1]).filter((secretName) => config.secrets?.required?.includes(secretName));
   if (missingSecretNames.length > 0) {
     err.preventReport();
-    throw new UserError(
+    throw new UserError$1(
       `The following required secrets have not been set: ${missingSecretNames.join(", ")}
 Use \`wrangler ${options.type === "deploy" ? "secret put" : "versions secret put"} <NAME>\` to set secrets before ${options.type === "deploy" ? "deploying" : "uploading"}.
 See https://developers.cloudflare.com/workers/configuration/secrets/#secrets-on-deployed-workers for more information.`,
@@ -10175,8 +12803,8 @@ function getSourceMappingPrepareStackTrace(retrieveSourceMap) {
     // Make sure we're using fresh copies of files each time we source map
     emptyCacheBetweenOperations: true,
     // Allow retriever to be overridden at prepare stack trace time
-    retrieveSourceMap(path8) {
-      return retrieveSourceMapOverride?.(path8) ?? null;
+    retrieveSourceMap(path9) {
+      return retrieveSourceMapOverride?.(path9) ?? null;
     }
   });
   sourceMappingPrepareStackTrace = Error.prepareStackTrace;
@@ -10389,7 +13017,7 @@ var validateRoutes = /* @__PURE__ */ __name((routes, assets) => {
     }
   }
   if (Object.keys(invalidRoutes).length > 0) {
-    throw new UserError(
+    throw new UserError$1(
       `Invalid Routes:
 ` + Object.entries(invalidRoutes).map(([route, errors]) => `${route}:
 ` + errors.join("\n")).join(`
@@ -10399,13 +13027,13 @@ var validateRoutes = /* @__PURE__ */ __name((routes, assets) => {
     );
   }
   if (mountedAssetRoutes.length > 0 && assets?.directory !== void 0) {
-    const relativeAssetsDir = path__default.relative(process.cwd(), assets.directory);
+    const relativeAssetsDir = path3__default.relative(process.cwd(), assets.directory);
     const warnFn = logger.once?.warn ?? logger.warn;
     warnFn(
       `Warning: The following routes will attempt to serve Assets on a configured path:
 ${mountedAssetRoutes.map((route) => {
         const routeNoScheme = route.replace(/https?:\/\//g, "");
-        const assetPath = path__default.join(
+        const assetPath = path3__default.join(
           relativeAssetsDir,
           routeNoScheme.substring(routeNoScheme.indexOf("/"))
         );
@@ -10416,7 +13044,7 @@ ${mountedAssetRoutes.map((route) => {
 }, "validateRoutes");
 
 // src/deploy/helpers/workers-sites-bindings.ts
-function addWorkersSitesBindings(bindings, namespace, manifest, format) {
+function addWorkersSitesBindings(bindings, namespace, manifest, format3) {
   const withSites = { ...bindings };
   if (namespace) {
     withSites["__STATIC_CONTENT"] = {
@@ -10424,7 +13052,7 @@ function addWorkersSitesBindings(bindings, namespace, manifest, format) {
       id: namespace
     };
   }
-  if (manifest && format === "service-worker") {
+  if (manifest && format3 === "service-worker") {
     withSites["__STATIC_CONTENT_MANIFEST"] = {
       type: "text_blob",
       source: { contents: "__STATIC_CONTENT_MANIFEST" }
@@ -10437,7 +13065,7 @@ __name(addWorkersSitesBindings, "addWorkersSitesBindings");
 // src/deploy/deploy.ts
 async function deploy(props, config, buildResult, callbacks) {
   if (!props.name) {
-    throw new UserError(
+    throw new UserError$1(
       'You need to provide a name when publishing a worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`',
       { telemetryMessage: "deploy command missing worker name" }
     );
@@ -10513,7 +13141,7 @@ Deploying the Worker will override the remote configuration with your local one.
             return { versionId, workerTag };
           }
         }
-      } else if (script.last_deployed_from === "api") {
+      } else if (script.last_deployed_from === "api" && !props.skipLastDeployedFromApiCheck) {
         logger.warn(
           `You are about to publish a Workers Service that was last updated via the script API.
 Edits that have been made via the script API will be overridden by your local code and config.`
@@ -10554,10 +13182,10 @@ Edits that have been made via the script API will be overridden by your local co
   }
   if (!compatibilityDate) {
     const compatibilityDateStr = getTodaysCompatDate();
-    throw new UserError(
-      `A compatibility_date is required when publishing. Add the following to your ${configFileName(config.configPath)} file:
+    throw new UserError$1(
+      `A compatibility_date is required when publishing. Add the following to your ${configFileName$1(config.configPath)} file:
     \`\`\`
-    ${formatConfigSnippet({ compatibility_date: compatibilityDateStr }, config.configPath, false)}
+    ${formatConfigSnippet$1({ compatibility_date: compatibilityDateStr }, config.configPath, false)}
     \`\`\`
     Or you could pass it in your terminal as \`--compatibility-date ${compatibilityDateStr}\`
 See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information.`,
@@ -10575,7 +13203,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   const useServiceEnvironments2 = props.useServiceEnvApiPath;
   const workerName = useServiceEnvironments2 ? `${scriptName} (${envName})` : scriptName;
   const workerUrl = props.dispatchNamespace ? `/accounts/${accountId}/workers/dispatch/namespaces/${props.dispatchNamespace}/scripts/${scriptName}` : useServiceEnvironments2 ? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}` : `/accounts/${accountId}/workers/scripts/${scriptName}`;
-  const { format } = entry;
+  const { format: format3 } = entry;
   const { projectRoot } = entry;
   if (!props.dispatchNamespace && !useServiceEnvironments2 && accountId && scriptName) {
     const yes = await confirmLatestDeploymentOverwrite(
@@ -10588,27 +13216,27 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       return { versionId, workerTag };
     }
   }
-  if (!props.isWorkersSite && Boolean(props.legacyAssetPaths) && format === "service-worker") {
-    throw new UserError(
+  if (!props.isWorkersSite && Boolean(props.legacyAssetPaths) && format3 === "service-worker") {
+    throw new UserError$1(
       "You cannot use the service-worker format with an `assets` directory yet. For information on how to migrate to the module-worker format, see: https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/",
       { telemetryMessage: "deploy service worker assets unsupported" }
     );
   }
-  if (config.wasm_modules && format === "modules") {
-    throw new UserError(
+  if (config.wasm_modules && format3 === "modules") {
+    throw new UserError$1(
       "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code",
       { telemetryMessage: "deploy wasm modules with es module worker" }
     );
   }
-  if (config.text_blobs && format === "modules") {
-    throw new UserError(
-      `You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName(config.configPath)} file`,
+  if (config.text_blobs && format3 === "modules") {
+    throw new UserError$1(
+      `You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName$1(config.configPath)} file`,
       { telemetryMessage: "[text_blobs] with an ES module worker" }
     );
   }
-  if (config.data_blobs && format === "modules") {
-    throw new UserError(
-      `You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName(config.configPath)} file`,
+  if (config.data_blobs && format3 === "modules") {
+    throw new UserError$1(
+      `You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName$1(config.configPath)} file`,
       { telemetryMessage: "[data_blobs] with an ES module worker" }
     );
   }
@@ -10686,7 +13314,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     });
   }
   const placement = parseConfigPlacement(config);
-  const entryPointName = path__default.basename(resolvedEntryPointPath);
+  const entryPointName = path3__default.basename(resolvedEntryPointPath);
   const main = {
     name: entryPointName,
     filePath: resolvedEntryPointPath,
@@ -10729,10 +13357,10 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     0
   );
   await printBundleSize(
-    { name: path__default.basename(resolvedEntryPointPath), content },
+    { name: path3__default.basename(resolvedEntryPointPath), content },
     modules
   );
-  const canUseNewVersionsDeploymentsApi = workerExists && props.dispatchNamespace === void 0 && !useServiceEnvironments2 && format === "modules" && migrations === void 0 && !config.first_party_worker && config.containers === void 0;
+  const canUseNewVersionsDeploymentsApi = workerExists && props.dispatchNamespace === void 0 && !useServiceEnvironments2 && format3 === "modules" && migrations === void 0 && !config.first_party_worker && config.containers === void 0;
   let workerBundle;
   const dockerPath = getDockerPath();
   if (normalisedContainerConfig.length && props.containersRollout !== "none") {
@@ -10767,7 +13395,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
         bindings ?? {},
         workersSitesAssets.namespace,
         workersSitesAssets.manifest,
-        format
+        format3
       ),
       {
         dryRun: true,
@@ -10800,7 +13428,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
         bindings ?? {},
         workersSitesAssets.namespace,
         workersSitesAssets.manifest,
-        format
+        format3
       ),
       {
         unsafe: config.unsafe
@@ -10906,7 +13534,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
         config.containers,
         { unsafeMetadata: config.unsafe?.metadata }
       );
-      versionId = parseNonHyphenedUuid(result.deployment_id);
+      versionId = parseNonHyphenedUuid$1(result.deployment_id);
       if (config.first_party_worker) {
         if (result.id) {
           logger.log("Worker ID: ", result.id);
@@ -10949,7 +13577,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
       if (err instanceof APIError && "code" in err && err.code === 10021 && err.notes.length > 0) {
         err.preventReport();
         if (err.notes[0].text === "binding DB of type d1 must have a valid `id` specified [code: 10021]") {
-          throw new UserError(
+          throw new UserError$1(
             "You must use a real database in the database_id configuration. You can find your databases using 'wrangler d1 list', or read how to develop locally with D1 here: https://developers.cloudflare.com/d1/configuration/local-development",
             { telemetryMessage: "deploy d1 database binding invalid id" }
           );
@@ -10977,7 +13605,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     }
   }
   if (props.outfile) {
-    mkdirSync(path__default.dirname(props.outfile), { recursive: true });
+    mkdirSync(path3__default.dirname(props.outfile), { recursive: true });
     const serializedFormData = await new Response(workerBundle).arrayBuffer();
     writeFileSync(props.outfile, Buffer.from(serializedFormData));
   }
@@ -11021,7 +13649,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 __name(deploy, "deploy");
 async function versionsUpload(props, config, buildResult, callbacks) {
   if (!props.name) {
-    throw new UserError(
+    throw new UserError$1(
       'You need to provide a name of your worker. Either pass it as a cli arg with `--name <name>` or in your config file as `name = "<name>"`',
       { telemetryMessage: "versions upload missing worker name" }
     );
@@ -11064,7 +13692,7 @@ Edits that have been made via the dashboard will be overridden by your local cod
             workerTag
           };
         }
-      } else if (script.last_deployed_from === "api") {
+      } else if (script.last_deployed_from === "api" && !props.skipLastDeployedFromApiCheck) {
         logger.warn(
           `You are about to upload a Workers Version that was last updated via the API.
 Edits that have been made via the API will be overridden by your local code and config.`
@@ -11084,10 +13712,10 @@ Edits that have been made via the API will be overridden by your local code and
   }
   if (!compatibilityDate) {
     const compatibilityDateStr = getTodaysCompatDate();
-    throw new UserError(
-      `A compatibility_date is required when uploading a Worker Version. Add the following to your ${configFileName(config.configPath)} file:
+    throw new UserError$1(
+      `A compatibility_date is required when uploading a Worker Version. Add the following to your ${configFileName$1(config.configPath)} file:
     \`\`\`
-	${formatConfigSnippet({ compatibility_date: compatibilityDateStr }, config.configPath, false)}
+	${formatConfigSnippet$1({ compatibility_date: compatibilityDateStr }, config.configPath, false)}
     \`\`\`
     Or you could pass it in your terminal as \`--compatibility-date ${compatibilityDateStr}\`
 See https://developers.cloudflare.com/workers/platform/compatibility-dates for more information.`,
@@ -11098,7 +13726,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   }
   const scriptName = name;
   if (config.site && !config.site.bucket) {
-    throw new UserError(
+    throw new UserError$1(
       "A [site] definition requires a `bucket` field with a path to the site's assets directory.",
       { telemetryMessage: "versions upload sites missing bucket" }
     );
@@ -11106,27 +13734,27 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   const start = Date.now();
   const workerName = scriptName;
   const workerUrl = `/accounts/${accountId}/workers/scripts/${scriptName}`;
-  const { format } = entry;
+  const { format: format3 } = entry;
   const projectRoot = entry.projectRoot;
-  if (config.wasm_modules && format === "modules") {
-    throw new UserError(
+  if (config.wasm_modules && format3 === "modules") {
+    throw new UserError$1(
       "You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code",
       {
         telemetryMessage: "versions upload wasm modules unsupported module worker"
       }
     );
   }
-  if (config.text_blobs && format === "modules") {
-    throw new UserError(
-      `You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName(config.configPath)} file`,
+  if (config.text_blobs && format3 === "modules") {
+    throw new UserError$1(
+      `You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName$1(config.configPath)} file`,
       {
         telemetryMessage: "versions upload text blobs unsupported module worker"
       }
     );
   }
-  if (config.data_blobs && format === "modules") {
-    throw new UserError(
-      `You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName(config.configPath)} file`,
+  if (config.data_blobs && format3 === "modules") {
+    throw new UserError$1(
+      `You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure \`[rules]\` in your ${configFileName$1(config.configPath)} file`,
       {
         telemetryMessage: "versions upload data blobs unsupported module worker"
       }
@@ -11172,7 +13800,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
   }
   addRequiredSecretsInheritBindings(config, bindings, { type: "upload" });
   const placement = parseConfigPlacement(config);
-  const entryPointName = path__default.basename(resolvedEntryPointPath);
+  const entryPointName = path3__default.basename(resolvedEntryPointPath);
   const main = {
     name: entryPointName,
     filePath: resolvedEntryPointPath,
@@ -11219,7 +13847,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     );
   }
   await printBundleSize(
-    { name: path__default.basename(resolvedEntryPointPath), content },
+    { name: path3__default.basename(resolvedEntryPointPath), content },
     modules
   );
   let workerBundle;
@@ -11299,7 +13927,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
         logger.error(message);
       }
       handleMissingSecretsError(err, config, { type: "upload" });
-      if (err instanceof ParseError && "code" in err && err.code === 10021 && err.notes.length > 0) {
+      if (err instanceof ParseError$1 && "code" in err && err.code === 10021 && err.notes.length > 0) {
         const maybeNameToFilePath = /* @__PURE__ */ __name((moduleName) => {
           if (bundleType === "commonjs") {
             return resolvedEntryPointPath;
@@ -11333,7 +13961,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     }
   }
   if (props.outfile) {
-    mkdirSync(path__default.dirname(props.outfile), { recursive: true });
+    mkdirSync(path3__default.dirname(props.outfile), { recursive: true });
     const serializedFormData = await new Response(workerBundle).arrayBuffer();
     writeFileSync(props.outfile, Buffer.from(serializedFormData));
   }
@@ -11342,7 +13970,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
     return { versionId, workerTag };
   }
   if (!accountId) {
-    throw new UserError("Missing accountId", {
+    throw new UserError$1("Missing accountId", {
       telemetryMessage: "versions upload missing account id"
     });
   }
@@ -11448,13 +14076,13 @@ function validateNodeCompatMode(compatibilityDateStr = "2000-01-01", compatibili
     hasExperimentalNodejsCompatV2Flag
   } = getNodeCompat(compatibilityDateStr, compatibilityFlags);
   if (hasExperimentalNodejsCompatV2Flag) {
-    throw new UserError(
+    throw new UserError$1(
       "The `experimental:` prefix on `nodejs_compat_v2` is no longer valid. Please remove it and try again.",
       { telemetryMessage: "experimental nodejs compat v2 prefix unsupported" }
     );
   }
   if (hasNodejsCompatFlag && hasNodejsCompatV2Flag) {
-    throw new UserError(
+    throw new UserError$1(
       "The `nodejs_compat` and `nodejs_compat_v2` compatibility flags cannot be used in together. Please select just one.",
       { telemetryMessage: "conflicting nodejs compat flags" }
     );