@lvce-editor/static-server 0.115.8 → 0.115.11

package/static/{5e50b2d → bb27a79}/packages/error-worker/dist/errorWorkerMain.js

@@ -15,7 +15,7 @@ class KyError extends Error {
 /**
 Error thrown when the response has a non-2xx status code and `throwHttpErrors` is enabled.
 
-The error has a `response` property with the `Response` object, a `request` property with the `Request` object, an `options` property with the normalized options (either passed to `ky` when creating an instance with `ky.create()` or directly when performing the request), and a `data` property with the pre-parsed response body. For JSON responses (based on `Content-Type`), the body is parsed using the `parseJson` option if set, or `JSON.parse` by default. For other content types, it is set as plain text. If the body is empty or parsing fails, `data` will be `undefined`. To avoid hanging or excessive buffering, `error.data` population is bounded by the request timeout and a 10 MiB response body size limit. The `data` property is populated before `beforeError` hooks run, so hooks can access it.
+The error has a `response` property with the `Response` object, a `request` property with the `Request` object, an `options` property with the normalized options (either passed to `ky` when creating an instance with `ky.create()` or directly when performing the request), and a `data` property with the pre-parsed response body. For JSON responses (based on `Content-Type`), the body is parsed using the `parseJson` option if set, or `JSON.parse` by default. For other content types, it is set as plain text. If the body is empty, unreadable, too large, parsing fails, or the error-data read/parse timeout is reached, `data` will be `undefined`. To avoid hanging or excessive buffering, `error.data` body reads and async JSON parsing are bounded by the request timeout (or 10 seconds when `timeout` is disabled), any remaining `totalTimeout` budget, and a 10 MiB response body size limit. If `totalTimeout` expires while populating `error.data`, Ky throws `TimeoutError` instead of `HTTPError`. The `data` property is populated before `beforeError` hooks run, so hooks can access it.
 
 The response body is automatically consumed when populating `error.data`, so `error.response.json()` and other body methods will not work. Use `error.data` instead. The `error.response` object is still available for headers, status, etc.
 
@@ -176,7 +176,7 @@ const supportsAbortController = typeof globalThis.AbortController === 'function'
 const supportsAbortSignal = typeof globalThis.AbortSignal === 'function' && typeof globalThis.AbortSignal.any === 'function';
 const supportsResponseStreams = typeof globalThis.ReadableStream === 'function';
 const supportsFormData = typeof globalThis.FormData === 'function';
-const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
+const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete', 'query'];
 const responseTypes = {
   json: 'application/json',
   text: 'text/*',
@@ -381,14 +381,13 @@ const withProgress = (stream, totalBytes, onProgress) => {
       previousChunk = currentChunk;
     },
     flush() {
-      if (previousChunk) {
-        transferredBytes += previousChunk.byteLength;
-        onProgress?.({
-          percent: 1,
-          totalBytes: Math.max(totalBytes, transferredBytes),
-          transferredBytes
-        }, previousChunk);
-      }
+      const finalChunk = previousChunk ?? new Uint8Array();
+      transferredBytes += finalChunk.byteLength;
+      onProgress?.({
+        percent: 1,
+        totalBytes: Math.max(totalBytes, transferredBytes),
+        transferredBytes
+      }, finalChunk);
     }
   }));
 };
@@ -557,7 +556,7 @@ const appendSearchParameters = (target, source) => {
   return result;
 };
 // TODO: Make this strongly-typed (no `any`).
-const deepMerge = (...sources) => {
+const deepMergeInternal = (isRoot, ...sources) => {
   let returnValue = {};
   let headers = {};
   let hooks = {};
@@ -571,16 +570,20 @@ const deepMerge = (...sources) => {
       returnValue = [...returnValue, ...source];
     } else if (isObject(source)) {
       for (let [key, value] of Object.entries(source)) {
-        // Special handling for AbortSignal instances
-        if (key === 'signal' && value instanceof globalThis.AbortSignal) {
-          signals.push(value);
-          continue;
-        }
         const replaceState = getReplaceState(value);
         const {
           isReplace
         } = replaceState;
         value = replaceState.value;
+        const isRootSignal = isRoot && key === 'signal';
+        if (isRootSignal && (isReplace || value === undefined)) {
+          signals.length = 0;
+        }
+        // Special handling for AbortSignal instances at the root options level
+        if (isRootSignal && value instanceof globalThis.AbortSignal) {
+          signals.push(value);
+          continue;
+        }
         // Special handling for context - shallow merge only
         if (key === 'context') {
           if (value !== undefined && value !== null && (!isObject(value) || Array.isArray(value))) {
@@ -612,8 +615,21 @@ const deepMerge = (...sources) => {
           }
           continue;
         }
+        // `retry` accepts a number as shorthand for `{limit: number}`. Expand it before
+        // merging so extending a numeric `retry` with an object keeps the limit instead
+        // of dropping it (e.g. `ky.create({retry: 3}).extend({retry: {methods: ['get']}})`).
+        // Scoped to the root options level so it never rewrites nested user data that
+        // happens to contain a `retry` key (e.g. a `json` request body).
+        if (isRoot && key === 'retry' && isObject(value) && !isReplace && typeof returnValue[key] === 'number') {
+          returnValue = {
+            ...returnValue,
+            [key]: {
+              limit: returnValue[key]
+            }
+          };
+        }
         if (isObject(value) && !isReplace && key in returnValue) {
-          value = deepMerge(returnValue[key], value);
+          value = deepMergeInternal(false, returnValue[key], value);
         }
         returnValue = {
           ...returnValue,
@@ -649,17 +665,19 @@ const deepMerge = (...sources) => {
     } else {
       // When AbortSignal.any is not available, use the last signal
       // This maintains the previous behavior before signal merging was added
-      // This can be remove when the `supportsAbortSignal` check is removed.`
+      // This can be removed when the `supportsAbortSignal` check is removed.
       returnValue.signal = signals.at(-1);
     }
   }
   return returnValue;
 };
+const deepMerge = (...sources) => deepMergeInternal(true, ...sources);
 
 const normalizeRequestMethod = input => requestMethods.includes(input) ? input.toUpperCase() : input;
-const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace'];
+const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace', 'query'];
 const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
 const retryAfterStatusCodes = [413, 429, 503];
+const invalidRetryLimitErrorMessage = '`retry.limit` must be a finite, non-negative integer';
 const defaultRetryOptions = {
   limit: 2,
   methods: retryMethods,
@@ -671,26 +689,58 @@ const defaultRetryOptions = {
   jitter: undefined,
   retryOnTimeout: false
 };
+const getDefaultRetryOptions = () => ({
+  ...defaultRetryOptions,
+  methods: [...defaultRetryOptions.methods],
+  statusCodes: [...defaultRetryOptions.statusCodes],
+  afterStatusCodes: [...defaultRetryOptions.afterStatusCodes]
+});
+/**
+Normalizes an omitted retry limit or validates a supplied one.
+*/
+const normalizeRetryLimit = retryLimit => {
+  if (retryLimit === undefined) {
+    return defaultRetryOptions.limit;
+  }
+  if (typeof retryLimit !== 'number' || !Number.isInteger(retryLimit) || retryLimit < 0) {
+    throw new TypeError(invalidRetryLimitErrorMessage);
+  }
+  return retryLimit;
+};
 const normalizeRetryOptions = (retry = {}) => {
   if (typeof retry === 'number') {
     return {
-      ...defaultRetryOptions,
-      limit: retry
+      ...getDefaultRetryOptions(),
+      limit: normalizeRetryLimit(retry)
     };
   }
-  if (retry.methods && !Array.isArray(retry.methods)) {
+  if (retry === null || typeof retry !== 'object' || Array.isArray(retry)) {
+    throw new TypeError('`retry` must be a number or an object');
+  }
+  const normalizedRetry = Object.fromEntries(Object.entries(retry).filter(([, value]) => value !== undefined));
+  const retryLimit = normalizeRetryLimit(normalizedRetry.limit);
+  if (normalizedRetry.methods !== undefined && !Array.isArray(normalizedRetry.methods)) {
     throw new Error('retry.methods must be an array');
   }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+  if (normalizedRetry.statusCodes !== undefined && !Array.isArray(normalizedRetry.statusCodes)) {
     throw new Error('retry.statusCodes must be an array');
   }
-  const normalizedRetry = Object.fromEntries(Object.entries({
-    ...retry,
-    methods: retry.methods?.map(method => method.toLowerCase())
-  }).filter(([, value]) => value !== undefined));
+  if (normalizedRetry.afterStatusCodes !== undefined && !Array.isArray(normalizedRetry.afterStatusCodes)) {
+    throw new Error('retry.afterStatusCodes must be an array');
+  }
+  if (normalizedRetry.methods !== undefined) {
+    normalizedRetry.methods = normalizedRetry.methods.map(method => method.toLowerCase());
+  }
+  if (normalizedRetry.statusCodes !== undefined) {
+    normalizedRetry.statusCodes = [...normalizedRetry.statusCodes];
+  }
+  if (normalizedRetry.afterStatusCodes !== undefined) {
+    normalizedRetry.afterStatusCodes = [...normalizedRetry.afterStatusCodes];
+  }
   return {
-    ...defaultRetryOptions,
-    ...normalizedRetry
+    ...getDefaultRetryOptions(),
+    ...normalizedRetry,
+    limit: retryLimit
   };
 };
 
@@ -770,7 +820,7 @@ const hasSearchParameters = search => {
   return Boolean(search);
 };
 
-// Inlined from https://github.com/sindresorhus/is-network-error v1.3.1
+// Inlined from https://github.com/sindresorhus/is-network-error v1.3.2
 const objectToString$1 = Object.prototype.toString;
 const isError = value => objectToString$1.call(value) === '[object Error]';
 const errorMessages = new Set(['network error',
@@ -799,7 +849,7 @@ function isRawNetworkError(error) {
     stack
   } = error;
   // Safari 17+ has generic message but no stack for network errors
-  if (message === 'Load failed') {
+  if (message === 'Load failed' || message.startsWith('Load failed (') && message.endsWith(')')) {
     return stack === undefined
     // Sentry adds its own stack trace to the fetch error, so also check for that
     || '__sentry_captured__' in error;
@@ -882,9 +932,148 @@ function isTimeoutError(error) {
   return isErrorType(error, TimeoutError);
 }
 
+// Older epoch-second values are indistinguishable from ordinary delay seconds, so timestamp compatibility only applies to current-era reset headers.
+const timestampThreshold = Date.parse('2024-01-01');
+const delayPattern = /^\d+$/;
+const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+// HTTP-date parsing is limited to IMF-fixdate and the two obsolete HTTP-date formats. Other date-like strings intentionally fall back to the normal retry delay.
+const imfDatePattern = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{2}):(\d{2}):(\d{2}) GMT$/;
+const rfc850DatePattern = /^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{2}):(\d{2}):(\d{2}) GMT$/;
+const asctimeDatePattern = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{2}| \d) (\d{2}:\d{2}:\d{2}) (\d{4})$/;
+const getRetryTimingHeader = headers => {
+  const retryAfter = headers.get('Retry-After');
+  if (retryAfter !== null) {
+    return {
+      value: retryAfter,
+      allowTimestamp: false
+    };
+  }
+  // Retry-After is authoritative when present. Only missing Retry-After falls through to rate-limit headers.
+  const rateLimitReset = headers.get('RateLimit-Reset');
+  if (rateLimitReset !== null) {
+    return {
+      value: rateLimitReset,
+      allowTimestamp: true
+    };
+  }
+  const rateLimitRetryAfter = headers.get('X-RateLimit-Retry-After'); // Symfony-based services
+  if (rateLimitRetryAfter !== null) {
+    return {
+      value: rateLimitRetryAfter,
+      allowTimestamp: false
+    };
+  }
+  const rateLimitResetAlias = headers.get('X-RateLimit-Reset') // GitHub
+  ?? headers.get('X-Rate-Limit-Reset'); // Twitter
+  if (rateLimitResetAlias !== null) {
+    return {
+      value: rateLimitResetAlias,
+      allowTimestamp: true
+    };
+  }
+  return undefined;
+};
+const createTimestamp = ({
+  year,
+  month,
+  day,
+  hours,
+  minutes,
+  seconds
+}) => {
+  const monthIndex = months.indexOf(month);
+  const dayNumber = Number(day);
+  const hoursNumber = Number(hours);
+  const minutesNumber = Number(minutes);
+  const secondsNumber = Number(seconds);
+  if (monthIndex === -1 || hoursNumber > 23 || minutesNumber > 59 || secondsNumber > 60) {
+    return undefined;
+  }
+  const normalizedSeconds = Math.min(secondsNumber, 59);
+  const date = new Date(Date.UTC(year, monthIndex, dayNumber, hoursNumber, minutesNumber, normalizedSeconds));
+  date.setUTCFullYear(year);
+  const timestamp = date.getTime();
+  // Date.UTC normalizes overflow, so round-trip the parts to reject invalid dates. A leap second is represented by parsing 60 as 59 and adding one second.
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== dayNumber || date.getUTCHours() !== hoursNumber || date.getUTCMinutes() !== minutesNumber || date.getUTCSeconds() !== normalizedSeconds) {
+    return undefined;
+  }
+  return secondsNumber === 60 ? timestamp + 1000 : timestamp;
+};
+const getCapture = (match, index) => match[index];
+const parseDate = value => {
+  const imfDate = imfDatePattern.exec(value);
+  if (imfDate) {
+    return createTimestamp({
+      year: Number(getCapture(imfDate, 3)),
+      month: getCapture(imfDate, 2),
+      day: getCapture(imfDate, 1),
+      hours: getCapture(imfDate, 4),
+      minutes: getCapture(imfDate, 5),
+      seconds: getCapture(imfDate, 6)
+    });
+  }
+  const rfc850Date = rfc850DatePattern.exec(value);
+  if (rfc850Date) {
+    const now = new Date();
+    const twoDigitYear = Number(getCapture(rfc850Date, 3));
+    const currentCenturyYear = Math.floor(now.getUTCFullYear() / 100) * 100 + twoDigitYear;
+    const fiftyYearsFromNow = Date.UTC(now.getUTCFullYear() + 50, now.getUTCMonth(), now.getUTCDate(), now.getUTCHours(), now.getUTCMinutes(), now.getUTCSeconds(), now.getUTCMilliseconds());
+    let timestamp;
+    // RFC 9110 maps two-digit years to the latest matching century that is not more than 50 years in the future.
+    for (const year of [currentCenturyYear - 100, currentCenturyYear, currentCenturyYear + 100]) {
+      const candidateTimestamp = createTimestamp({
+        year,
+        month: getCapture(rfc850Date, 2),
+        day: getCapture(rfc850Date, 1),
+        hours: getCapture(rfc850Date, 4),
+        minutes: getCapture(rfc850Date, 5),
+        seconds: getCapture(rfc850Date, 6)
+      });
+      if (candidateTimestamp !== undefined && candidateTimestamp <= fiftyYearsFromNow) {
+        timestamp = candidateTimestamp;
+      }
+    }
+    return timestamp;
+  }
+  const asctimeDate = asctimeDatePattern.exec(value);
+  if (asctimeDate) {
+    const time = getCapture(asctimeDate, 4);
+    const [hours, minutes, seconds] = time.split(':');
+    return createTimestamp({
+      year: Number(getCapture(asctimeDate, 5)),
+      month: getCapture(asctimeDate, 2),
+      day: getCapture(asctimeDate, 3).trim(),
+      hours,
+      minutes,
+      seconds
+    });
+  }
+  return undefined;
+};
+const calculateRetryTimingDelay = ({
+  value,
+  allowTimestamp
+}) => {
+  if (delayPattern.test(value)) {
+    let delay = Number(value) * 1000;
+    // Standard Retry-After numbers are delay seconds. Timestamp compatibility only applies to reset headers.
+    if (allowTimestamp && delay >= timestampThreshold) {
+      delay -= Date.now();
+    }
+    return Math.max(0, delay);
+  }
+  const timestamp = parseDate(value);
+  if (timestamp === undefined) {
+    return undefined;
+  }
+  const delay = timestamp - Date.now();
+  return Number.isFinite(delay) ? Math.max(0, delay) : undefined;
+};
+
 const maxErrorResponseBodySize = 10 * 1024 * 1024;
 const prefixUrlRenamedErrorMessage = 'The `prefixUrl` option has been renamed `prefix` in v2 and enhanced to allow slashes in input. See also the new `baseUrl` option for improved flexibility with standard URL resolution: https://github.com/sindresorhus/ky#baseurl';
 const timedOutResponseData = Symbol('timedOutResponseData');
+const timedOutOperation = Symbol('timedOutOperation');
 const createTextDecoder = contentType => {
   const match = /;\s*charset\s*=\s*(?:"([^"]+)"|([^;,\s]+))/i.exec(contentType);
   const charset = match?.[1] ?? match?.[2];
@@ -897,29 +1086,36 @@ const createTextDecoder = contentType => {
 };
 const invalidSchemaMessage = 'The `schema` argument must follow the Standard Schema specification';
 const cloneRetryOptions = retry => {
-  if (typeof retry !== 'object') {
+  if (retry === null || typeof retry !== 'object' || Array.isArray(retry)) {
     return retry;
   }
-  // Clone nested arrays too so init hooks can mutate retry config without leaking state across requests.
-  return {
-    ...retry,
-    ...(retry.methods && {
-      methods: [...retry.methods]
-    }),
-    ...(retry.statusCodes && {
-      statusCodes: [...retry.statusCodes]
-    }),
-    ...(retry.afterStatusCodes && {
-      afterStatusCodes: [...retry.afterStatusCodes]
-    })
+  const clonedRetry = {
+    ...retry
   };
+  // Clone nested arrays too so init hooks can mutate retry config without leaking state across requests.
+  if (Array.isArray(clonedRetry.methods)) {
+    clonedRetry.methods = [...clonedRetry.methods];
+  }
+  if (Array.isArray(clonedRetry.statusCodes)) {
+    clonedRetry.statusCodes = [...clonedRetry.statusCodes];
+  }
+  if (Array.isArray(clonedRetry.afterStatusCodes)) {
+    clonedRetry.afterStatusCodes = [...clonedRetry.afterStatusCodes];
+  }
+  return clonedRetry;
 };
 const objectToString = Object.prototype.toString;
+const leadingC0ControlOrSpacePattern = /^[\0-\u0020]+/g;
+const asciiTabOrNewLinePattern = /[\t\n\r]/g;
+const schemePattern = /^[a-z][\d+.a-z-]*:/i;
+const malformedHttpProtocolPattern = /^https?:(?!\/\/)/i;
 const isRequestInstance = value => value instanceof globalThis.Request || objectToString.call(value) === '[object Request]';
 // Accepted custom responses are treated as full Responses throughout Ky.
 // If a custom fetch returns one, it must behave like a Response for cloning,
 // body consumption, `json()` decoration, and any enabled stream features.
 const isResponseInstance = value => value instanceof globalThis.Response || objectToString.call(value) === '[object Response]';
+const isAbsoluteInput = input => schemePattern.test(input);
+const normalizeInputForProtocolCheck = input => input.replaceAll(leadingC0ControlOrSpacePattern, '').replaceAll(asciiTabOrNewLinePattern, '');
 const cloneSearchParametersForInitHook = searchParameters => {
   if (Array.isArray(searchParameters)) {
     return searchParameters.map(parameter => [...parameter]);
@@ -972,6 +1168,9 @@ class Ky {
       // Delay the fetch so that body method shortcuts can set the Accept header
       await Promise.resolve();
       const beforeRequestResponse = await ky.#runBeforeRequestHooks();
+      if (beforeRequestResponse !== undefined) {
+        ky.#retryLimit = normalizeRetryOptions(ky.#options.retry).limit;
+      }
       let response = beforeRequestResponse ?? (await ky.#retry(async () => ky.#fetch()));
       let responseFromHook = beforeRequestResponse !== undefined || ky.#consumeReturnedResponseFromBeforeRetryHook();
       for (;;) {
@@ -1044,31 +1243,7 @@ class Ky {
       try {
         return await function_();
       } catch (error) {
-        // Non-Error throws (e.g., thrown strings) pass through unchanged
-        if (!(error instanceof Error)) {
-          throw error;
-        }
-        // Errors thrown by beforeRetry hooks must propagate unchanged.
-        if (ky.#beforeRetryHookErrors.has(error)) {
-          throw error;
-        }
-        let processedError = error;
-        for (const hook of ky.#options.hooks.beforeError) {
-          // `request` is the current failing request. `options` intentionally remains the
-          // stable normalized Ky options snapshot for the same reason as `HTTPError` above.
-          // eslint-disable-next-line no-await-in-loop
-          const hookResult = await hook({
-            request: ky.request,
-            options: ky.#getNormalizedOptions(),
-            error: processedError,
-            retryCount: ky.#retryCount
-          });
-          // Only overwrite if the hook returns a valid Error instance.
-          if (hookResult instanceof Error) {
-            processedError = hookResult;
-          }
-        }
-        throw processedError;
+        await ky.#throwProcessedError(error);
       } finally {
         const originalRequest = ky.#originalRequest;
         // Ignore cancellation errors from already-locked or already-consumed streams.
@@ -1089,20 +1264,21 @@ class Ky {
         ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
         const response = await result;
         if (type !== 'json') {
-          return response[type]();
+          return ky.#raceBodyRead(async () => response[type](), response);
         }
-        const text = await response.text();
-        if (text === '') {
-          if (schema !== undefined) {
-            return validateJsonWithSchema(undefined, schema);
-          }
-          return JSON.parse(text);
+        const text = await ky.#raceBodyRead(async () => response.text(), response);
+        const request = ky.#getResponseRequest(response);
+        const parsedResult = await ky.#raceWithTotalTimeout(async () => {
+          const jsonValue = initHookOptions.parseJson ? await initHookOptions.parseJson(text, {
+            request,
+            response
+          }) : text === '' && schema !== undefined ? undefined : JSON.parse(text);
+          return schema === undefined ? jsonValue : validateJsonWithSchema(jsonValue, schema);
+        });
+        if (parsedResult === timedOutOperation) {
+          await ky.#throwProcessedError(new TimeoutError(request));
         }
-        const jsonValue = initHookOptions.parseJson ? await initHookOptions.parseJson(text, {
-          request: ky.#getResponseRequest(response),
-          response
-        }) : JSON.parse(text);
-        return schema === undefined ? jsonValue : validateJsonWithSchema(jsonValue, schema);
+        return parsedResult;
       };
     }
     return result;
@@ -1118,7 +1294,7 @@ class Ky {
   request;
   #abortController;
   #retryCount = 0;
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly -- False positive: #input is reassigned on line 202
+  #retryLimit;
   #input;
   #options;
   #originalRequest;
@@ -1148,6 +1324,7 @@ class Ky {
       fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
       context: options.context ?? {}
     };
+    this.#retryLimit = this.#options.retry.limit;
     if (typeof this.#input !== 'string' && !(this.#input instanceof URL || this.#input instanceof globalThis.Request)) {
       throw new TypeError('`input` must be a string, URL, or Request');
     }
@@ -1158,11 +1335,11 @@ class Ky {
         this.#input = `${normalizedPrefix}/${normalizedInput}`;
       }
       if (this.#options.baseUrl) {
-        let absoluteInput;
-        try {
-          absoluteInput = new URL(this.#input);
-        } catch {}
-        if (!absoluteInput) {
+        const normalizedInput = normalizeInputForProtocolCheck(this.#input);
+        if (malformedHttpProtocolPattern.test(normalizedInput)) {
+          throw new TypeError('`input` url protocol must be followed by `//` when using `baseUrl`');
+        }
+        if (!isAbsoluteInput(normalizedInput)) {
           this.#input = new URL(this.#input, new Request(this.#options.baseUrl).url);
         }
       }
@@ -1224,97 +1401,90 @@ class Ky {
     // Ky's internal scheduling and user hook time before the first fetch attempt.
     this.#startTime = typeof this.#options.totalTimeout === 'number' ? this.#getCurrentTime() : undefined;
   }
-  #calculateDelay() {
-    const retryDelay = this.#options.retry.delay(this.#retryCount + 1);
+  #calculateDelay(retry) {
+    const retryDelay = retry.delay(this.#retryCount + 1);
     let jitteredDelay = retryDelay;
-    if (this.#options.retry.jitter === true) {
+    if (retry.jitter === true) {
       jitteredDelay = Math.random() * retryDelay;
-    } else if (typeof this.#options.retry.jitter === 'function') {
-      jitteredDelay = this.#options.retry.jitter(retryDelay);
+    } else if (typeof retry.jitter === 'function') {
+      jitteredDelay = retry.jitter(retryDelay);
       if (!Number.isFinite(jitteredDelay) || jitteredDelay < 0) {
         jitteredDelay = retryDelay;
       }
     }
-    return Math.min(this.#options.retry.backoffLimit, jitteredDelay);
+    return Math.min(retry.backoffLimit, jitteredDelay);
   }
   async #calculateRetryDelay(error) {
-    if (this.#retryCount >= this.#options.retry.limit) {
+    const retry = normalizeRetryOptions(this.#options.retry);
+    if (this.#retryCount >= Math.min(retry.limit, this.#retryLimit)) {
       throw error;
     }
     // Wrap non-Error throws to ensure consistent error handling
     const errorObject = error instanceof Error ? error : new NonError(error);
     // Handle forced retry from afterResponse hook - skip method check and shouldRetry
     if (errorObject instanceof ForceRetryError) {
-      return errorObject.customDelay ?? this.#calculateDelay();
+      return errorObject.customDelay ?? this.#calculateDelay(retry);
     }
     // Check if method is retriable for non-forced retries
-    if (!this.#options.retry.methods.includes(this.request.method.toLowerCase())) {
+    if (!retry.methods.includes(this.request.method.toLowerCase())) {
       throw error;
     }
-    // User-provided shouldRetry function takes precedence over default checks (retryOnTimeout, status codes, etc.)
-    if (this.#options.retry.shouldRetry !== undefined) {
-      const result = await this.#options.retry.shouldRetry({
+    const {
+      shouldRetry
+    } = retry;
+    if (shouldRetry !== undefined) {
+      const result = await this.#raceWithTotalTimeout(async () => shouldRetry({
         error: errorObject,
         retryCount: this.#retryCount + 1
-      });
-      // Strict boolean checking - only exact true/false are handled specially
+      }));
+      if (result === timedOutOperation) {
+        throw new TimeoutError(this.request);
+      }
+      // Only exact booleans override the default retry checks.
       if (result === false) {
         throw error;
       }
       if (result === true) {
-        // Force retry - skip all other validation and return delay
-        return this.#calculateDelay();
+        return this.#calculateDelay(retry);
       }
-      // If undefined or any other value, fall through to default behavior
     }
     // Default timeout behavior
     if (isTimeoutError(error)) {
-      if (!this.#options.retry.retryOnTimeout) {
+      if (!retry.retryOnTimeout) {
         throw error;
       }
-      return this.#calculateDelay();
+      return this.#calculateDelay(retry);
     }
     if (isHTTPError(error)) {
-      if (!this.#options.retry.statusCodes.includes(error.response.status)) {
+      if (!retry.statusCodes.includes(error.response.status)) {
         throw error;
       }
-      const retryAfter = error.response.headers.get('Retry-After') ?? error.response.headers.get('RateLimit-Reset') ?? error.response.headers.get('X-RateLimit-Retry-After') // Symfony-based services
-      ?? error.response.headers.get('X-RateLimit-Reset') // GitHub
-      ?? error.response.headers.get('X-Rate-Limit-Reset'); // Twitter
-      if (retryAfter && this.#options.retry.afterStatusCodes.includes(error.response.status)) {
-        let after = Number(retryAfter) * 1000;
-        if (Number.isNaN(after)) {
-          after = Date.parse(retryAfter) - Date.now();
-        } else if (after >= Date.parse('2024-01-01')) {
-          // A large number is treated as a timestamp (fixed threshold protects against clock skew)
-          after -= Date.now();
-        }
-        if (!Number.isFinite(after)) {
-          return Math.min(this.#options.retry.maxRetryAfter, this.#calculateDelay());
-        }
-        after = Math.max(0, after);
+      const retryTimingHeader = getRetryTimingHeader(error.response.headers);
+      if (retryTimingHeader && retry.afterStatusCodes.includes(error.response.status)) {
+        const after = calculateRetryTimingDelay(retryTimingHeader);
+        if (after === undefined) {
+          // Malformed retry timing headers should not disable retries; they only lose their server-provided timing.
+          return this.#calculateDelay(retry);
+        }
         // Don't apply jitter when server provides explicit retry timing
-        return Math.min(this.#options.retry.maxRetryAfter, after);
+        return Math.min(retry.maxRetryAfter, after);
       }
       if (error.response.status === 413) {
         throw error;
       }
-      return this.#calculateDelay();
+      return this.#calculateDelay(retry);
     }
     // Only retry known retriable error types. Unknown errors (e.g., programming bugs) are not retried.
     if (!isNetworkError(error)) {
       throw error;
     }
-    return this.#calculateDelay();
+    return this.#calculateDelay(retry);
   }
   #decorateResponse(response) {
     const request = this.#getResponseRequest(response);
     if (this.#options.parseJson) {
       response.json = async () => {
         const text = await response.text();
-        if (text === '') {
-          return JSON.parse(text);
-        }
         return this.#options.parseJson(text, {
           request,
           response
@@ -1323,11 +1493,42 @@ class Ky {
     }
     return response;
   }
+  async #throwProcessedError(error) {
+    // Non-Error throws (e.g., thrown strings) pass through unchanged
+    if (!(error instanceof Error)) {
+      throw error;
+    }
+    // Errors thrown by beforeRetry hooks must propagate unchanged.
+    if (this.#beforeRetryHookErrors.has(error)) {
+      throw error;
+    }
+    let processedError = error;
+    for (const hook of this.#options.hooks.beforeError) {
+      // `request` is the current failing request. `options` intentionally remains the
+      // stable normalized Ky options snapshot for the same reason as `HTTPError` above.
+      // eslint-disable-next-line no-await-in-loop
+      const hookResult = await hook({
+        request: this.request,
+        options: this.#getNormalizedOptions(),
+        error: processedError,
+        retryCount: this.#retryCount
+      });
+      // Only overwrite if the hook returns a valid Error instance.
+      if (hookResult instanceof Error) {
+        processedError = hookResult;
+      }
+    }
+    throw processedError;
+  }
   async #getResponseData(response) {
     // Even with request timeouts disabled, bound error-body reads so retries and error propagation
     // cannot be stalled indefinitely by never-ending response streams.
-    const text = await this.#readResponseText(response, this.#getErrorDataTimeout());
+    const readTimeout = this.#getErrorDataTimeout();
+    const text = await this.#readResponseText(response, readTimeout.milliseconds);
     if (text === timedOutResponseData) {
+      if (readTimeout.fromTotalTimeout) {
+        throw new TimeoutError(this.request);
+      }
       this.#throwIfTotalTimeoutExhausted();
       return undefined;
     }
@@ -1337,8 +1538,12 @@ class Ky {
     if (!this.#isJsonContentType(response.headers.get('content-type') ?? '')) {
       return text;
     }
-    const data = await this.#parseJson(text, response, this.#getErrorDataTimeout(), this.#getResponseRequest(response));
+    const parseTimeout = this.#getErrorDataTimeout();
+    const data = await this.#parseJson(text, response, parseTimeout.milliseconds, this.#getResponseRequest(response));
     if (data === timedOutResponseData) {
+      if (parseTimeout.fromTotalTimeout) {
+        throw new TimeoutError(this.request);
+      }
       this.#throwIfTotalTimeoutExhausted();
       return undefined;
     }
@@ -1348,12 +1553,105 @@ class Ky {
     const errorDataTimeout = this.#options.timeout === false ? 10_000 : this.#options.timeout;
     const remainingTotal = this.#getRemainingTotalTimeout();
     if (remainingTotal === undefined) {
-      return errorDataTimeout;
+      return {
+        milliseconds: errorDataTimeout,
+        fromTotalTimeout: false
+      };
     }
     if (remainingTotal <= 0) {
       throw new TimeoutError(this.request);
     }
-    return Math.min(errorDataTimeout, remainingTotal);
+    return {
+      milliseconds: Math.min(errorDataTimeout, remainingTotal),
+      fromTotalTimeout: remainingTotal <= errorDataTimeout
+    };
+  }
+  #getBodyReadTimeout() {
+    const remainingTotal = this.#getRemainingTotalTimeout();
+    if (remainingTotal !== undefined) {
+      if (remainingTotal <= 0) {
+        throw new TimeoutError(this.request);
+      }
+      return this.#options.timeout === false ? remainingTotal : Math.min(this.#options.timeout, remainingTotal);
+    }
+    return this.#options.timeout === false ? undefined : this.#options.timeout;
+  }
+  // Unlike error bodies (`#getResponseData`), a successful body read has no fallback value to return -
+  // the caller's `.json()`/`.text()`/etc. promise must settle, so a timeout here always rejects.
+  async #raceBodyRead(createBodyPromise, response) {
+    let timeoutMs;
+    try {
+      timeoutMs = this.#getBodyReadTimeout();
+    } catch (error) {
+      await this.#throwProcessedError(error);
+    }
+    const bodyPromise = createBodyPromise();
+    if (timeoutMs === undefined) {
+      return bodyPromise;
+    }
+    const result = await Promise.race([bodyPromise, new Promise(resolve => {
+      const timeoutId = setTimeout(() => {
+        resolve(timedOutResponseData);
+      }, timeoutMs);
+      void bodyPromise.finally(() => {
+        clearTimeout(timeoutId);
+      }).catch(() => undefined);
+    })]);
+    if (result === timedOutResponseData) {
+      // The stream is locked by the native body method's own reader by this point, so
+      // `response.body.cancel()` would reject as "already locked". Aborting the request's
+      // signal is what actually interrupts the underlying network read.
+      this.#abortController?.abort();
+      await this.#throwProcessedError(new TimeoutError(this.#getResponseRequest(response)));
+    }
+    return result;
+  }
+  async #raceWithTotalTimeout(operation) {
+    const remainingTotal = this.#getRemainingTotalTimeout();
+    if (remainingTotal === undefined) {
+      return operation();
+    }
+    if (remainingTotal <= 0) {
+      this.#abortController?.abort();
+      return timedOutOperation;
+    }
+    let timeoutId;
+    try {
+      const timeoutPromise = new Promise(resolve => {
+        timeoutId = setTimeout(() => {
+          resolve(timedOutOperation);
+        }, remainingTotal);
+      });
+      const operationResult = Promise.resolve().then(operation).then(value => ({
+        status: 'fulfilled',
+        value
+      })).catch(error => ({
+        status: 'rejected',
+        error
+      }));
+      const result = await Promise.race([operationResult, timeoutPromise]);
+      const remainingAfterOperation = this.#getRemainingTotalTimeout();
+      const didTimeOut = result === timedOutOperation || remainingAfterOperation !== undefined && remainingAfterOperation <= 0;
+      if (didTimeOut) {
+        this.#abortController?.abort();
+        if (result === timedOutOperation) {
+          void operationResult.then(result => {
+            if (result.status === 'fulfilled') {
+              this.#cancelReturnedBody(result.value);
+            }
+          });
+        } else if (result.status === 'fulfilled') {
+          this.#cancelReturnedBody(result.value);
+        }
+        return timedOutOperation;
+      }
+      if (result.status === 'rejected') {
+        throw result.error;
+      }
+      return result.value;
+    } finally {
+      clearTimeout(timeoutId);
+    }
   }
   #isJsonContentType(contentType) {
     // Match JSON subtypes like `json`, `problem+json`, and `vnd.api+json`.
@@ -1449,6 +1747,13 @@ class Ky {
     // Ignore cancellation failures from already-locked or already-consumed streams.
     this.#cancelBody(response.body ?? undefined);
   }
+  #cancelReturnedBody(value) {
+    if (isResponseInstance(value)) {
+      this.#cancelResponseBody(value);
+    } else if (isRequestInstance(value)) {
+      this.#cancelBody(value.body ?? undefined);
+    }
+  }
   #createManagedSignal() {
     return this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
   }
@@ -1461,11 +1766,14 @@ class Ky {
   async #runBeforeRequestHooks() {
     for (const hook of this.#options.hooks.beforeRequest) {
       // eslint-disable-next-line no-await-in-loop
-      const result = await hook({
+      const result = await this.#raceWithTotalTimeout(async () => hook({
         request: this.request,
         options: this.#getNormalizedOptions(),
         retryCount: 0
-      });
+      }));
+      if (result === timedOutOperation) {
+        throw new TimeoutError(this.request);
+      }
       if (isRequestInstance(result)) {
         this.#assignRequest(result);
       } else if (isResponseInstance(result)) {
@@ -1482,12 +1790,15 @@ class Ky {
       let modifiedResponse;
       try {
         // eslint-disable-next-line no-await-in-loop
-        modifiedResponse = await hook({
+        modifiedResponse = await this.#raceWithTotalTimeout(async () => hook({
           request: this.request,
           options: this.#getNormalizedOptions(),
           response: hookResponse,
           retryCount: this.#retryCount
-        });
+        }));
+        if (modifiedResponse === timedOutOperation) {
+          throw new TimeoutError(this.request);
+        }
       } catch (error) {
         // Cancel both responses to prevent memory leaks when hook throws
         if (hookResponse !== response) {
@@ -1561,12 +1872,12 @@ class Ky {
       let hookResult;
       try {
         // eslint-disable-next-line no-await-in-loop
-        hookResult = await hook({
+        hookResult = await this.#raceWithTotalTimeout(async () => hook({
           request: this.request,
           options: this.#getNormalizedOptions(),
           error: error,
           retryCount: this.#retryCount + 1
-        });
+        }));
       } catch (hookError) {
         // Preserve the original request error path (`throw error`) so beforeError hooks can still run.
         if (hookError instanceof Error && hookError !== error) {
@@ -1574,6 +1885,9 @@ class Ky {
         }
         throw hookError;
       }
+      if (hookResult === timedOutOperation) {
+        throw new TimeoutError(this.request);
+      }
       if (isRequestInstance(hookResult)) {
         // Same contract as `ky.retry({request})`: a Request returned from `beforeRetry`
         // is used as-is rather than being sanitized or otherwise rewritten by Ky.
@@ -1610,7 +1924,8 @@ class Ky {
       });
     }
     const nonRequestOptions = findUnknownOptions(this.#options);
-    const retryRequest = this.#options.retry.limit > 0 ? this.request.clone() : undefined;
+    this.#retryLimit = normalizeRetryOptions(this.#options.retry).limit;
+    const retryRequest = this.#retryLimit > 0 ? this.request.clone() : undefined;
     const request = this.#wrapRequestWithUploadProgress(this.request, this.#options.body ?? undefined);
     // Cloning is done here to prepare in advance for retries.
     // Skip cloning when retries are disabled - cloning a streaming body calls ReadableStream#tee()
@@ -3479,7 +3794,7 @@ const prepareErrorMessageWithCodeFrame = error => {
   const lines = cleanStack(error.stack);
   const relevantStack = formatStack(lines, getOrigin());
   if (error.codeFrame) {
-    const type = error.constructor.name;
+    const type = getType$1(error);
     return {
       _error: error,
       codeFrame: error.codeFrame,
@@ -3511,11 +3826,18 @@ const toAbsoluteUrl = (file, relativePath) => {
   return url.href;
 };
 const getType$1 = error => {
-  const constructorName = error.constructor.name;
+  const constructorName = error?.constructor?.name;
+  if (constructorName === 'DOMException') {
+    return constructorName;
+  }
+  const name = error?.name;
+  if (name && name !== 'Error') {
+    return name;
+  }
   if (constructorName === 'Object') {
     return 'Error';
   }
-  return constructorName;
+  return constructorName || 'Error';
 };
 const formatMessageWithType = (type, message) => {
   const prefix = `${type}: `;
@@ -3569,7 +3891,7 @@ const prepareErrorMessageWithoutCodeFrame = async (error, options) => {
           line: originalLine
         }
       });
-      const type = error.constructor.name;
+      const type = getType$1(error);
       return {
         _error: error,
         codeFrame,
@@ -5027,13 +5349,11 @@ const types = {
   j_cTag: new TokContext("</tag"),
   j_expr: new TokContext("<tag>...</tag>", true)
 };
-const nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088f\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5c\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdc-\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7dc\ua7f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-const nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1add\u1ae0-\u1aeb\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489];
-const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
-function isInAstralSet(code, set) {
+const bmpIdentifierStart$1 = /[\p{ID_Start}\u088f\u0c5c\u0cdc\ua7ce\ua7cf\ua7d2\ua7d4\ua7f1]/u;
+const bmpIdentifier$1 = /[\p{ID_Continue}\u088f\u0c5c\u0cdc\ua7ce\ua7cf\ua7d2\ua7d4\ua7f1\u1acf-\u1add\u1ae0-\u1aeb]/u;
+const supplementaryIdentifierStartCodes$1 = [2368, 25, 1388, 2, 3817, 43, 20677, 24, 3, 24, 287, 4, 6146, 7, 1290, 21, 98, 114, 22734, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 53307, 5, 5987, 11, 21763, 4297];
+const supplementaryIdentifierCodes$1 = [3834, 1, 3173, 7, 633, 9, 51450, 0, 3, 0, 8, 1, 6, 0];
+function isInSupplementarySet$1(code, set) {
   let pos = 0x10000;
   for (let i = 0, length = set.length; i < length; i += 2) {
     pos += set[i];
@@ -5049,9 +5369,9 @@ function isIdentifierStart$1(code) {
   if (code < 97) return code === 95;
   if (code <= 122) return true;
   if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+    return code >= 0xaa && bmpIdentifierStart$1.test(String.fromCharCode(code));
   }
-  return isInAstralSet(code, astralIdentifierStartCodes);
+  return !isNaN(code) && code <= 0x10ffff && (bmpIdentifierStart$1.test(String.fromCodePoint(code)) || isInSupplementarySet$1(code, supplementaryIdentifierStartCodes$1));
 }
 function isIdentifierChar$1(code) {
   if (code < 48) return code === 36;
@@ -5061,9 +5381,9 @@ function isIdentifierChar$1(code) {
   if (code < 97) return code === 95;
   if (code <= 122) return true;
   if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+    return code >= 0xaa && bmpIdentifier$1.test(String.fromCharCode(code));
   }
-  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+  return !isNaN(code) && code <= 0x10ffff && (bmpIdentifier$1.test(String.fromCodePoint(code)) || isInSupplementarySet$1(code, supplementaryIdentifierStartCodes$1) || isInSupplementarySet$1(code, supplementaryIdentifierCodes$1));
 }
 const reservedWords$1 = {
   keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
@@ -9177,11 +9497,6 @@ class Token {
   }
 }
 let locDataCache;
-function resetLocData() {
-  const data = locDataCache;
-  locDataCache = undefined;
-  return data;
-}
 class Tokenizer extends CommentsParser {
   isLookahead;
   tokens = [];
@@ -9193,7 +9508,7 @@ class Tokenizer extends CommentsParser {
     this.length = input.length;
     this.comments = [];
     this.isLookahead = false;
-    if (!locDataCache || locDataCache.length < (this.length + 1) * 2 || options.locations === "packed") {
+    if (!locDataCache || locDataCache.length < (this.length + 1) * 2) {
       locDataCache = new Uint32Array((this.length + 1) * 2);
     }
     this.locData = locDataCache;
@@ -11208,9 +11523,6 @@ class ExpressionParser extends LValParser {
     if (this.optionFlags & 512) {
       expr.tokens = createExportedTokens(this.tokens);
     }
-    if (this.options.locations === "packed") {
-      expr.locData = resetLocData();
-    }
     return expr;
   }
   parseExpression(disallowIn, refExpressionErrors) {
@@ -14535,6 +14847,8 @@ const TSErrorTemplates = {
   ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
   ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
   ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
+  DeclaratorDefiniteAssertionRequiresTypeAnnotation: "Declarations with definite assignment assertions must also have type annotations.",
+  DeclaratorDefiniteAssertionWithInitializer: "Declarations with initializers cannot also have definite assignment assertions.",
   DeclareAccessor: ({
     kind
   }) => `'declare' is not allowed in ${kind}ters.`,
@@ -14552,6 +14866,7 @@ const TSErrorTemplates = {
   EmptyHeritageClauseType: ({
     token
   }) => `'${token}' list cannot be empty.`,
+  EmptyNamespaceName: "Namespace must be given a name.",
   EmptyTypeArguments: "Type argument list cannot be empty.",
   EmptyTypeParameters: "Type parameter list cannot be empty.",
   ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
@@ -14588,6 +14903,7 @@ const TSErrorTemplates = {
   InvalidModifiersOrder: ({
     orderedModifiers
   }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
+  InvalidNamespaceName: value => `Namespace name cannot be '${value}'.`,
   InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
   InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
   MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
@@ -15866,7 +16182,21 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       node.id = this.parseIdentifier();
     } else {
       node.kind = "module";
-      node.id = super.parseStringLiteral(this.state.value);
+      const {
+        type,
+        value
+      } = this.state;
+      if (type === 130) {
+        node.id = super.parseStringLiteral(value);
+      } else if (tokenIsIdentifier(type)) {
+        this.raise(TSErrors.InlineModuleDeclarationMustUseString, this.state.startLoc);
+        node.id = this.tsParseEntityName(0);
+      } else if (type === 2) {
+        this.raise(TSErrors.EmptyNamespaceName, this.state.startLoc);
+      } else {
+        this.raise(TSErrors.InvalidNamespaceName, this.state.startLoc, value);
+        node.id = super.parseExprAtom();
+      }
     }
     if (this.match(2)) {
       if (!isGlobal) {
@@ -16411,20 +16741,29 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
       isAmbientContext
     } = this.state;
     const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
-    if (!isAmbientContext) return declaration;
-    if (!node.declare && (kind === "using" || kind === "await using")) {
+    if (isAmbientContext && !node.declare && (kind === "using" || kind === "await using")) {
       this.raiseOverwrite(TSErrors.UsingDeclarationInAmbientContext, node, kind);
       return declaration;
     }
-    for (const {
-      id,
-      init
-    } of declaration.declarations) {
-      if (!init) continue;
-      if (kind === "var" || kind === "let" || !!id.typeAnnotation) {
-        this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
-      } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
-        this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
+    for (const declarator of declaration.declarations) {
+      const {
+        id,
+        init,
+        definite
+      } = declarator;
+      if (definite) {
+        if (init) {
+          this.raise(TSErrors.DeclaratorDefiniteAssertionWithInitializer, id);
+        } else if (!id.typeAnnotation) {
+          this.raise(TSErrors.DeclaratorDefiniteAssertionRequiresTypeAnnotation, id);
+        }
+      }
+      if (isAmbientContext && init) {
+        if (kind === "var" || kind === "let" || !!id.typeAnnotation) {
+          this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
+        } else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
+          this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
+        }
       }
     }
     return declaration;
@@ -16695,6 +17034,13 @@ const typescript = superClass => class TypeScriptParserMixin extends superClass
     }
     const type = this.tsTryParseTypeAnnotation();
     if (type) node.typeAnnotation = type;
+    if (node.definite) {
+      if (this.match(25)) {
+        this.raise(TSErrors.DeclaratorDefiniteAssertionWithInitializer, node);
+      } else if (!type) {
+        this.raise(TSErrors.DeclaratorDefiniteAssertionRequiresTypeAnnotation, node);
+      }
+    }
   }
   parseClassProperty(node) {
     this.parseClassPropertyAnnotation(node);
@@ -17825,9 +18171,6 @@ class Parser extends StatementParser {
     const result = this.parseTopLevel(file, program);
     result.errors = this.state.errors;
     result.comments.length = this.state.commentsLen;
-    if (this.options.locations === "packed") {
-      result.locData = resetLocData();
-    }
     return result;
   }
 }