@farm.js/core 0.1.0-beta.1 → 0.1.0-beta.4

package/types/client.d.ts

@@ -8,11 +8,15 @@
 
 import type {
   AnchorHTMLAttributes,
+  ComponentType,
+  FormEvent,
+  FormHTMLAttributes,
   ReactElement,
   ReactNode,
   RefObject,
   RefAttributes,
 } from "react";
+import type { DefinedCacheKey, InferCacheKeyData, RouteDataCacheKey } from "@farm.js/core/cache";
 
 declare module "@farm.js/core/client" {
   export interface MiddlewareProps {
@@ -378,6 +382,36 @@ declare module "@farm.js/core/client" {
     key: CacheKey<TData>;
   };
 
+  export interface FarmAPIStream<TItem> extends AsyncIterable<TItem> {
+    readonly response: Response;
+    cancel(reason?: unknown): Promise<void>;
+  }
+
+  export class APIClientError<
+    TCode extends string = string,
+    TData = unknown,
+    TStatus extends number = number,
+  > extends Error {
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    readonly response?: Response;
+
+    constructor(
+      code: TCode,
+      data: TData,
+      options: {
+        status: TStatus;
+        message: string;
+        response?: Response;
+      },
+    );
+  }
+
+  export type APIClientSystemError =
+    | APIClientError<"http_error", unknown, number>
+    | APIClientError<"network_error", unknown, 0>;
+
   export type RequestEvent = {
     requestId: string;
     method: StatusEvent["method"];
@@ -406,7 +440,7 @@ declare module "@farm.js/core/client" {
   export type CachePolicy = "cache-first" | "network-only" | "stale-while-revalidate";
 
   export type CacheOptions = {
-    key?: string;
+    key?: RouteDataCacheKey;
     policy?: CachePolicy;
     staleTime?: number;
     gcTime?: number;
@@ -419,9 +453,9 @@ declare module "@farm.js/core/client" {
   };
 
   export type InvalidateTarget =
-    | string
+    | RouteDataCacheKey
     | {
-        key: string;
+        key: RouteDataCacheKey;
       }
     | {
         path: string;
@@ -439,7 +473,7 @@ declare module "@farm.js/core/client" {
 
   export type OptimisticUpdate =
     | [CallableRouteRef<any>, unknown, (prev: any) => any]
-    | [CacheKey<any> | string, (prev: any) => any];
+    | [CacheKey<any> | DefinedCacheKey<any> | string, (prev: any) => any];
 
   export type OptimisticOptions<TUpdates extends readonly unknown[] = readonly OptimisticUpdate[]> =
     {
@@ -452,7 +486,7 @@ declare module "@farm.js/core/client" {
     TError = unknown,
     TUpdates extends readonly unknown[] = readonly OptimisticUpdate[],
   > = {
-    key?: CacheKey<TData> | string;
+    key?: CacheKey<TData> | RouteDataCacheKey;
     cache?: CacheOptions;
     retry?: RetryOptions;
     invalidate?: InvalidateOptions;
@@ -496,11 +530,13 @@ declare module "@farm.js/core/client" {
         ]
       : never
     : TUpdate extends readonly [infer TKey, (prev: any) => any]
-      ? TKey extends CacheKey<infer TData>
-        ? [TKey, (prev: TData | undefined) => TData]
-        : TKey extends string
-          ? [TKey, (prev: unknown) => unknown]
-          : never
+      ? TKey extends DefinedCacheKey<any, RouteDataCacheKey>
+        ? [TKey, (prev: InferCacheKeyData<TKey> | undefined) => InferCacheKeyData<TKey>]
+        : TKey extends CacheKey<infer TData>
+          ? [TKey, (prev: TData | undefined) => TData]
+          : TKey extends string
+            ? [TKey, (prev: unknown) => unknown]
+            : never
       : never;
 
   type NormalizeOptimisticUpdates<TUpdates extends readonly unknown[]> = {
@@ -514,8 +550,10 @@ declare module "@farm.js/core/client" {
   type TypedEndpointLike = {
     __types: {
       body: any;
+      inputBody?: any;
       query: any;
       response: any;
+      errors?: any;
     };
   };
 
@@ -554,13 +592,26 @@ declare module "@farm.js/core/client" {
   type HasRequiredKeys<T> = RequiredKeys<T> extends never ? false : true;
 
   // Type utilities to extract endpoint input/output types
+  type InferEndpointBody<T> = T extends {
+    __types: {
+      inputBody: infer TInputBody;
+    };
+  }
+    ? TInputBody
+    : T extends {
+          __types: {
+            body: infer TBody;
+          };
+        }
+      ? TBody
+      : never;
+
   type InferEndpointInput<T> = T extends {
     __types: {
-      body: infer TBody;
       query: infer TQuery;
     };
   }
-    ? SimplifyEndpointInput<BodyInputProp<TBody> & QueryInputProp<TQuery>>
+    ? SimplifyEndpointInput<BodyInputProp<InferEndpointBody<T>> & QueryInputProp<TQuery>>
     : {};
 
   type InferEndpointOutput<T> = T extends {
@@ -568,24 +619,177 @@ declare module "@farm.js/core/client" {
       response: infer R;
     };
   }
-    ? R
+    ? R extends { readonly __farmStreamItem: infer TItem }
+      ? FarmAPIStream<TItem>
+      : R
     : any;
 
+  type InferEndpointError<T> = T extends {
+    __types: {
+      errors: infer TErrors;
+    };
+  }
+    ? keyof TErrors extends never
+      ? Error
+      :
+          | {
+              [TCode in keyof TErrors]: TErrors[TCode] extends {
+                data: infer TData;
+                status: infer TStatus extends number;
+              }
+                ? APIClientError<TCode & string, TData, TStatus>
+                : never;
+            }[keyof TErrors]
+          | APIClientSystemError
+    : Error;
+
   type EndpointMethod<T = any> = (<
     TUpdates extends readonly unknown[] = readonly OptimisticUpdate[],
   >(
     ...args: HasRequiredKeys<InferEndpointInput<T>> extends true
       ? [
           options: InferEndpointInput<T>,
-          clientOptions?: ClientOptions<InferEndpointOutput<T>, Error, TUpdates>,
+          clientOptions?: ClientOptions<InferEndpointOutput<T>, InferEndpointError<T>, TUpdates>,
         ]
       : [
           options?: InferEndpointInput<T>,
-          clientOptions?: ClientOptions<InferEndpointOutput<T>, Error, TUpdates>,
+          clientOptions?: ClientOptions<InferEndpointOutput<T>, InferEndpointError<T>, TUpdates>,
         ]
-  ) => Promise<APIResult<InferEndpointOutput<T>, Error>>) &
+  ) => Promise<APIResult<InferEndpointOutput<T>, InferEndpointError<T>>>) &
     RouteRef<InferEndpointOutput<T>, InferEndpointInput<T>>;
 
+  export type MutationStatus = "idle" | "pending" | "success" | "error";
+
+  export type AnyMutationTarget = (...args: any[]) => Promise<any>;
+
+  export type InferMutationVariables<TTarget extends AnyMutationTarget> =
+    Parameters<TTarget> extends [] ? undefined : Parameters<TTarget>[0];
+
+  export type InferMutationData<TTarget extends AnyMutationTarget> = TTarget extends {
+    readonly __farmRouteData: infer TData;
+  }
+    ? TData
+    : Awaited<ReturnType<TTarget>>;
+
+  export type InferMutationError<TTarget extends AnyMutationTarget> = TTarget extends (
+    ...args: any[]
+  ) => Promise<APIResult<any, infer TError>>
+    ? TError
+    : Error;
+
+  export type MutationOptimisticContext<TVariables, TData> = {
+    variables: TVariables | undefined;
+    current: TData | null;
+  };
+
+  export type UseMutationOptions<TVariables, TData, TError = Error> = {
+    initialData?: TData | null;
+    resetOnMutate?: boolean;
+    optimistic?: (
+      context: MutationOptimisticContext<TVariables, TData>,
+    ) => TData | null | undefined;
+    rollbackOnError?: boolean;
+    request?: ClientOptions<TData, TError>;
+    onSuccess?: (data: TData, variables: TVariables | undefined) => void;
+    onError?: (error: TError, variables: TVariables | undefined) => void;
+    onSettled?: (
+      data: TData | null,
+      error: TError | null,
+      variables: TVariables | undefined,
+    ) => void;
+  };
+
+  export type MutationAsync<TTarget extends AnyMutationTarget, TData = InferMutationData<TTarget>> =
+    [] extends Parameters<TTarget>
+      ? (variables?: InferMutationVariables<TTarget>) => Promise<TData>
+      : (variables: InferMutationVariables<TTarget>) => Promise<TData>;
+
+  export type MutationTrigger<TTarget extends AnyMutationTarget> =
+    [] extends Parameters<TTarget>
+      ? (variables?: InferMutationVariables<TTarget>) => void
+      : (variables: InferMutationVariables<TTarget>) => void;
+
+  export type UseMutationReturn<
+    TTarget extends AnyMutationTarget,
+    TData = InferMutationData<TTarget>,
+    TError = InferMutationError<TTarget>,
+  > = {
+    pending: boolean;
+    status: MutationStatus;
+    data: TData | null;
+    error: TError | null;
+    variables: InferMutationVariables<TTarget> | undefined;
+    mutate: MutationTrigger<TTarget>;
+    mutateAsync: MutationAsync<TTarget, TData>;
+    reset: () => void;
+  };
+
+  export function useMutation<TTarget extends AnyMutationTarget>(
+    target: TTarget,
+    options?: UseMutationOptions<
+      InferMutationVariables<TTarget>,
+      InferMutationData<TTarget>,
+      InferMutationError<TTarget>
+    >,
+  ): UseMutationReturn<TTarget>;
+
+  export type FetcherState = "idle" | "submitting";
+
+  export type FetcherFormDataContext = {
+    form: HTMLFormElement | null;
+    submitter: HTMLElement | null;
+  };
+
+  export type UseFetcherOptions<TTarget extends AnyMutationTarget> = UseMutationOptions<
+    InferMutationVariables<TTarget>,
+    InferMutationData<TTarget>,
+    InferMutationError<TTarget>
+  > & {
+    mapFormData?: (
+      formData: FormData,
+      context: FetcherFormDataContext,
+    ) => InferMutationVariables<TTarget>;
+  };
+
+  export type FetcherFormProps = Omit<
+    FormHTMLAttributes<HTMLFormElement>,
+    "action" | "onSubmit"
+  > & {
+    action?: string | ((formData: FormData) => void | Promise<void>);
+    onSubmit?: (event: FormEvent<HTMLFormElement>) => void;
+  };
+
+  type FetcherInput<TTarget extends AnyMutationTarget> = InferMutationVariables<TTarget> | FormData;
+
+  export type FetcherSubmitAsync<TTarget extends AnyMutationTarget> =
+    [] extends Parameters<TTarget>
+      ? (input?: FetcherInput<TTarget>) => Promise<InferMutationData<TTarget>>
+      : (input: FetcherInput<TTarget>) => Promise<InferMutationData<TTarget>>;
+
+  export type FetcherSubmit<TTarget extends AnyMutationTarget> =
+    [] extends Parameters<TTarget>
+      ? (input?: FetcherInput<TTarget>) => void
+      : (input: FetcherInput<TTarget>) => void;
+
+  export type UseFetcherReturn<TTarget extends AnyMutationTarget> = {
+    state: FetcherState;
+    status: MutationStatus;
+    pending: boolean;
+    data: InferMutationData<TTarget> | null;
+    error: InferMutationError<TTarget> | null;
+    variables: InferMutationVariables<TTarget> | undefined;
+    formData: FormData | null;
+    submit: FetcherSubmit<TTarget>;
+    submitAsync: FetcherSubmitAsync<TTarget>;
+    Form: ComponentType<FetcherFormProps>;
+    reset: () => void;
+  };
+
+  export function useFetcher<TTarget extends AnyMutationTarget>(
+    target: TTarget,
+    options?: UseFetcherOptions<TTarget>,
+  ): UseFetcherReturn<TTarget>;
+
   type RouterToClient<T> = {
     [K in keyof T]: T[K] extends TypedEndpointLike
       ? EndpointMethod<T[K]>

package/dist/chunk-4PTK6KT4.mjs

@@ -1,364 +0,0 @@
-import {
-  notifyFarmCacheInvalidation
-} from "./chunk-TXCFGOHW.mjs";
-import {
-  getActiveFarmI18nSnapshot
-} from "./chunk-WZ5QFROO.mjs";
-import {
-  emitFarmEvent
-} from "./chunk-7ZY5AIJO.mjs";
-import {
-  __name
-} from "./chunk-CGILA3WO.mjs";
-
-// src/cache.ts
-var _FarmDataCache = class _FarmDataCache {
-  constructor() {
-    this.entries = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
-    this.version = 0;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  get(key, options = {}) {
-    return this.getEntry(key, options)?.value;
-  }
-  getEntry(key, options = {}) {
-    const entry = this.entries.get(key);
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    const stale = this.isStale(entry, options.now);
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: Array.from(entry.tags),
-        revalidate: entry.revalidate
-      });
-    }
-    if (!options.allowStale && stale) {
-      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      return void 0;
-    }
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: Array.from(entry.tags),
-      revalidate: entry.revalidate,
-      stale
-    });
-    return this.toPublicEntry(entry);
-  }
-  set(key, value, options = {}) {
-    const tags = /* @__PURE__ */ new Set();
-    for (const tag of options.tags ?? []) {
-      tags.add(normalizeCacheTag(tag));
-    }
-    for (const routePath of options.paths ?? []) {
-      tags.add(createPathCacheTag(routePath));
-    }
-    const entry = {
-      key,
-      value,
-      tags,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: ++this.version,
-      revalidate: normalizeRevalidate(options.revalidate)
-    };
-    this.entries.set(key, entry);
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: Array.from(tags),
-      revalidate: entry.revalidate
-    });
-    return this.toPublicEntry(entry);
-  }
-  delete(key) {
-    const deleted = this.entries.delete(key);
-    emitFarmEvent({ type: "cache.delete", key, deleted });
-    return deleted;
-  }
-  clear() {
-    const count = this.entries.size;
-    this.entries.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.version = 0;
-    emitFarmEvent({ type: "cache.clear", count });
-  }
-  isStale(entry, now = Date.now()) {
-    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    for (const tag of entry.tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
-      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
-        return true;
-      }
-    }
-    return false;
-  }
-  revalidateTag(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  revalidatePath(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async getOrSet(key, producer, options = {}) {
-    const cached = this.getEntry(key);
-    if (cached) {
-      return cached.value;
-    }
-    const inflight = this.inflight.get(key);
-    if (inflight) {
-      emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight;
-    }
-    const promise = Promise.resolve().then(producer).then((value) => {
-      this.set(key, value, options);
-      return value;
-    }).catch((error) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      this.inflight.delete(key);
-    });
-    this.inflight.set(key, promise);
-    return promise;
-  }
-  countEntriesForTag(tag) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (entry.tags.has(tag)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  countEntriesForTags(tags) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (tags.every((tag) => entry.tags.has(tag))) {
-        count++;
-      }
-    }
-    return count;
-  }
-  invalidateTag(normalizedTag) {
-    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    return this.countEntriesForTag(normalizedTag);
-  }
-  toPublicEntry(entry) {
-    return {
-      key: entry.key,
-      value: entry.value,
-      tags: Array.from(entry.tags),
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion,
-      revalidate: entry.revalidate
-    };
-  }
-};
-__name(_FarmDataCache, "FarmDataCache");
-var FarmDataCache = _FarmDataCache;
-var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
-var farmDataCacheGlobal = globalThis;
-var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
-var functionIds = /* @__PURE__ */ new WeakMap();
-var nextFunctionId = 0;
-function getFarmDataCache() {
-  return sharedFarmDataCache;
-}
-__name(getFarmDataCache, "getFarmDataCache");
-function unstable_cache(fn, keyParts = [], options = {}) {
-  return async (...args) => {
-    const locale = getActiveFarmI18nSnapshot()?.locale;
-    const key = createFarmCacheKey([
-      "unstable_cache",
-      getFunctionCacheIdentity(fn),
-      locale ? ["locale", locale] : null,
-      keyParts,
-      args
-    ]);
-    return getFarmDataCache().getOrSet(key, () => fn(...args), options);
-  };
-}
-__name(unstable_cache, "unstable_cache");
-function revalidateTag(_tag, _profile) {
-  getFarmDataCache().revalidateTag(_tag, {
-    source: "revalidateTag",
-    profile: _profile
-  });
-}
-__name(revalidateTag, "revalidateTag");
-function updateTag(tag) {
-  getFarmDataCache().revalidateTag(tag, { source: "updateTag" });
-}
-__name(updateTag, "updateTag");
-function revalidatePath(routePath) {
-  getFarmDataCache().revalidatePath(routePath);
-}
-__name(revalidatePath, "revalidatePath");
-function invalidate(key) {
-  const clientKey = createRouteDataCacheKey(key);
-  getFarmDataCache().revalidateTag(createRouteDataCacheTag(key), { source: "updateTag" });
-  notifyFarmCacheInvalidation(clientKey);
-}
-__name(invalidate, "invalidate");
-function invalidateRouteData(key) {
-  invalidate(key);
-}
-__name(invalidateRouteData, "invalidateRouteData");
-function createPathCacheTag(routePath) {
-  return `path:${normalizeRevalidatePath(routePath)}`;
-}
-__name(createPathCacheTag, "createPathCacheTag");
-function createRouteDataCacheTag(key) {
-  return `route-data:${createRouteDataCacheKey(key)}`;
-}
-__name(createRouteDataCacheTag, "createRouteDataCacheTag");
-function createRouteDataCacheKey(key) {
-  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
-}
-__name(createRouteDataCacheKey, "createRouteDataCacheKey");
-function normalizeRevalidatePath(routePath) {
-  if (typeof routePath !== "string") {
-    throw new TypeError("revalidatePath expects a path string.");
-  }
-  let normalized = routePath.trim();
-  if (!normalized) {
-    throw new Error("revalidatePath expects a non-empty path.");
-  }
-  try {
-    if (/^https?:\/\//.test(normalized)) {
-      normalized = new URL(normalized).pathname;
-    }
-  } catch {
-  }
-  normalized = normalized.split("?")[0] ?? normalized;
-  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  normalized = normalized.replace(/\/{2,}/g, "/");
-  if (normalized.length > 1) {
-    normalized = normalized.replace(/\/+$/, "");
-  }
-  return normalized || "/";
-}
-__name(normalizeRevalidatePath, "normalizeRevalidatePath");
-function createFarmCacheKey(parts) {
-  return stableSerialize(parts);
-}
-__name(createFarmCacheKey, "createFarmCacheKey");
-function normalizeRevalidate(revalidate) {
-  if (revalidate === false || revalidate === void 0) {
-    return revalidate;
-  }
-  if (!Number.isFinite(revalidate) || revalidate <= 0) {
-    return void 0;
-  }
-  return revalidate;
-}
-__name(normalizeRevalidate, "normalizeRevalidate");
-function normalizeCacheTag(tag) {
-  if (typeof tag !== "string") {
-    throw new TypeError("Cache tags must be strings.");
-  }
-  const normalized = tag.trim();
-  if (!normalized) {
-    throw new Error("Cache tags cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheTag, "normalizeCacheTag");
-function getFunctionCacheIdentity(fn) {
-  if (fn.name) {
-    return `name:${fn.name}`;
-  }
-  let id = functionIds.get(fn);
-  if (!id) {
-    id = ++nextFunctionId;
-    functionIds.set(fn, id);
-  }
-  return `anonymous:${id}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const valueType = typeof value;
-  if (valueType === "string") return JSON.stringify(value);
-  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
-    return `${valueType}:${String(value)}`;
-  }
-  if (valueType === "symbol") {
-    return `symbol:${String(value)}`;
-  }
-  if (valueType === "function") {
-    return `function:${getFunctionCacheIdentity(value)}`;
-  }
-  if (value instanceof Date) {
-    return `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => a.localeCompare(b)
-    );
-    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
-    seen.delete(value);
-    return `{${serialized}}`;
-  }
-  return String(value);
-}
-__name(stableSerialize, "stableSerialize");
-
-export {
-  FarmDataCache,
-  getFarmDataCache,
-  unstable_cache,
-  revalidateTag,
-  updateTag,
-  revalidatePath,
-  invalidate,
-  invalidateRouteData,
-  createPathCacheTag,
-  createRouteDataCacheTag,
-  createRouteDataCacheKey,
-  normalizeRevalidatePath,
-  createFarmCacheKey
-};
-//# sourceMappingURL=chunk-4PTK6KT4.mjs.map