@upstart.gg/sdk 0.0.133 → 0.0.135

package/dist/shared/chunk-BW6EFRSF.js

@@ -0,0 +1,794 @@
+/*! Upstart.gg - Copyright (C) 2024 Flippable - https://github.com/upstart-gg/upstart/blob/main/LICENSE */
+
+import {
+  tags
+} from "./chunk-Q4NPPLEU.js";
+import {
+  fontSize,
+  textContent
+} from "./chunk-F22LDHEO.js";
+import {
+  direction
+} from "./chunk-Y74LZNND.js";
+import {
+  shadow,
+  textShadow
+} from "./chunk-TNMNMYOB.js";
+import {
+  icon,
+  urlOrPageId
+} from "./chunk-UQF52PWK.js";
+import {
+  image
+} from "./chunk-W6MRYRGJ.js";
+import {
+  border,
+  rounding
+} from "./chunk-NTLAKMMQ.js";
+import {
+  colorPreset
+} from "./chunk-TFGGYU6Y.js";
+import {
+  borderColor,
+  color
+} from "./chunk-SE6O65HC.js";
+import {
+  hidden
+} from "./chunk-2RK3CPYJ.js";
+import {
+  cssLength
+} from "./chunk-BPBKHEQ5.js";
+import {
+  alignItems,
+  alignSelf,
+  justifyContent
+} from "./chunk-ZLYIRH2B.js";
+import {
+  background,
+  backgroundColor
+} from "./chunk-RV7AYVFV.js";
+import {
+  typedRef
+} from "./chunk-A2QPY54H.js";
+import {
+  StringEnum
+} from "./chunk-JK2FWFJU.js";
+
+// src/shared/bricks/props/dynamic.ts
+import { Type as Type2 } from "@sinclair/typebox";
+
+// src/shared/datasources/types.ts
+import { Type } from "@sinclair/typebox";
+
+// src/shared/utils/llm.ts
+import { cloneDeep } from "lodash-es";
+function toLLMSchema(schema) {
+  return cleanSchemaRecursive(inlineSchemaRefs(schema));
+}
+function cleanSchemaRecursive(schema) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "metadata" || key.startsWith("ui:")) {
+      continue;
+    }
+    if (value && typeof value === "object") {
+      if (Array.isArray(value)) {
+        cleaned[key] = value.map((item) => {
+          if (item && typeof item === "object" && isSchemaLike(item)) {
+            return cleanSchemaRecursive(item);
+          }
+          return item;
+        });
+      } else if (isSchemaLike(value)) {
+        cleaned[key] = cleanSchemaRecursive(value);
+      } else if (key === "properties" || key === "definitions" || key === "$defs" || key === "patternProperties") {
+        const cleanedProps = {};
+        for (const [propKey, propValue] of Object.entries(value)) {
+          if (propValue && typeof propValue === "object") {
+            const propSchema = propValue;
+            if (propSchema["ai:hidden"] === true) {
+              continue;
+            }
+            cleanedProps[propKey] = cleanSchemaRecursive(propValue);
+          } else {
+            cleanedProps[propKey] = propValue;
+          }
+        }
+        cleaned[key] = cleanedProps;
+      } else {
+        cleaned[key] = value;
+      }
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function isSchemaLike(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  const schemaKeys = [
+    "type",
+    "$ref",
+    "properties",
+    "items",
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "not",
+    "if",
+    "then",
+    "else"
+  ];
+  return schemaKeys.some((key) => key in obj);
+}
+function inlineSchemaRefs(schema) {
+  const inlinedSchema = cloneDeep(schema);
+  const collectedRefs = /* @__PURE__ */ new Set();
+  if (!inlinedSchema.$defs) {
+    inlinedSchema.$defs = {};
+  }
+  function collectRefs(obj) {
+    if (typeof obj !== "object" || obj === null) return;
+    if (Array.isArray(obj)) {
+      obj.forEach(collectRefs);
+      return;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "$ref" && typeof value === "string") {
+        if (!value.startsWith("#/")) {
+          collectedRefs.add(value);
+        }
+      } else {
+        collectRefs(value);
+      }
+    }
+  }
+  function convertRefsToLocal(obj, refMap) {
+    if (typeof obj !== "object" || obj === null) return obj;
+    if (Array.isArray(obj)) {
+      return obj.map((item) => convertRefsToLocal(item, refMap));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "$ref" && typeof value === "string") {
+        const localRef = refMap.get(value);
+        result[key] = localRef || value;
+      } else {
+        result[key] = convertRefsToLocal(value, refMap);
+      }
+    }
+    return result;
+  }
+  collectRefs(inlinedSchema);
+  const refToLocalMap = /* @__PURE__ */ new Map();
+  for (const refId of collectedRefs) {
+    const referencedSchema = schemaRegistry.get(refId);
+    if (!referencedSchema) {
+      continue;
+    }
+    const defKey = refId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || refId.split("/").pop()?.replace(/[^a-zA-Z0-9_-]/g, "_") || `ref_${Object.keys(inlinedSchema.$defs).length}`;
+    let uniqueDefKey = defKey;
+    let counter = 1;
+    while (inlinedSchema.$defs[uniqueDefKey]) {
+      uniqueDefKey = `${defKey}_${counter}`;
+      counter++;
+    }
+    const { $id, ...schemaWithoutId } = referencedSchema;
+    inlinedSchema.$defs[uniqueDefKey] = schemaWithoutId;
+    refToLocalMap.set(refId, `#/$defs/${uniqueDefKey}`);
+  }
+  const finalSchema = convertRefsToLocal(inlinedSchema, refToLocalMap);
+  if (finalSchema.$defs) {
+    let foundNewRefs = true;
+    while (foundNewRefs) {
+      foundNewRefs = false;
+      const newRefsFound = /* @__PURE__ */ new Set();
+      for (const [defKey, defSchema] of Object.entries(finalSchema.$defs)) {
+        let collectDefsRefs2 = function(obj) {
+          if (typeof obj !== "object" || obj === null) return;
+          if (Array.isArray(obj)) {
+            obj.forEach(collectDefsRefs2);
+            return;
+          }
+          for (const [key, value] of Object.entries(obj)) {
+            if (key === "$ref" && typeof value === "string") {
+              const refId = value.startsWith("#/") ? value : value;
+              if (!refId.startsWith("#/")) {
+                defCollectedRefs.add(refId);
+              }
+            } else {
+              collectDefsRefs2(value);
+            }
+          }
+        };
+        var collectDefsRefs = collectDefsRefs2;
+        const defCollectedRefs = /* @__PURE__ */ new Set();
+        collectDefsRefs2(defSchema);
+        for (const refId of defCollectedRefs) {
+          if (!refToLocalMap.has(refId)) {
+            newRefsFound.add(refId);
+            foundNewRefs = true;
+          }
+        }
+      }
+      for (const refId of newRefsFound) {
+        const referencedSchema = schemaRegistry.get(refId);
+        if (referencedSchema) {
+          const newDefKey = refId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || `ref_${Object.keys(finalSchema.$defs).length}`;
+          let uniqueNewDefKey = newDefKey;
+          let counter = 1;
+          while (finalSchema.$defs[uniqueNewDefKey]) {
+            uniqueNewDefKey = `${newDefKey}_${counter}`;
+            counter++;
+          }
+          finalSchema.$defs[uniqueNewDefKey] = referencedSchema;
+          refToLocalMap.set(refId, `#/$defs/${uniqueNewDefKey}`);
+        }
+      }
+    }
+    for (const [defKey, defSchema] of Object.entries(finalSchema.$defs)) {
+      finalSchema.$defs[defKey] = convertRefsToLocal(defSchema, refToLocalMap);
+    }
+  }
+  return finalSchema;
+}
+
+// src/shared/datasources/types.ts
+var providersSchema = Type.Union([
+  // Type.Literal("facebook-posts"),
+  // Type.Literal("instagram-feed"),
+  // Type.Literal("mastodon-account"),
+  // Type.Literal("mastodon-status"),
+  // Type.Literal("mastodon-status-list"),
+  Type.Literal("internal")
+  // Type.Literal("rss"),
+  // // Type.Literal("threads-media"),
+  // // Type.Literal("tiktok-video"),
+  // Type.Literal("youtube-list"),
+  // Type.Literal("http-json"),
+  // Type.Literal("internal-blog"),
+  // Type.Literal("internal-changelog"),
+  // // Type.Literal("internal-contact-info"),
+  // Type.Literal("internal-faq"),
+  // Type.Literal("internal-links"),
+  // Type.Literal("internal-recipes"),
+  // Type.Literal("internal-restaurant"),
+  // Type.Literal("internal-cv"),
+]);
+var datasourceInternalManifest = Type.Object(
+  {
+    id: Type.String({
+      title: "ID",
+      description: "Unique identifier of the datasource. Used to reference the datasource in the system. Use a url-safe string like a slug."
+    }),
+    label: Type.String({ title: "Label", description: "Label of the datasource displayed in the UI" }),
+    provider: Type.Literal("internal", {
+      title: "Internal",
+      description: "Internal datasource saved locally in Upstart."
+    }),
+    schema: Type.Any({
+      title: "Schema",
+      description: "JSON Schema of datasource. MUST Always an array of objects."
+    }),
+    indexes: Type.Optional(
+      Type.Array(
+        Type.Object({
+          name: Type.String({ title: "Index name" }),
+          fields: Type.Array(Type.String(), { title: "Fields to index" }),
+          unique: Type.Optional(Type.Boolean({ title: "Unique index", default: false }))
+        }),
+        {
+          title: "Indexes",
+          description: "IMPORTANT: Indexes to create on the datasource. use it to enforce uniqueness or improve query performance."
+        }
+      )
+    )
+  },
+  {
+    examples: [
+      {
+        id: "customers",
+        label: "Customers",
+        provider: "internal",
+        schema: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", title: "Name" },
+              email: { type: "string", title: "Email", format: "email" }
+            },
+            required: ["name", "email"],
+            title: "Customer",
+            examples: [
+              { name: "John Doe", email: "john.doe@example.com" },
+              {
+                name: "Jane Smith",
+                email: "jane.smith@example.com"
+              },
+              {
+                name: "Alice Johnson",
+                email: "alice.johnson@example.com"
+              },
+              {
+                name: "Bob Brown",
+                email: "bob.brown@example.com"
+              },
+              {
+                name: "Charlie Davis",
+                email: "charlie.davis@example.com"
+              }
+            ]
+          }
+        },
+        indexes: [
+          {
+            name: "idx_customers_email",
+            fields: ["email"],
+            unique: true
+          }
+        ]
+      },
+      {
+        id: "blog_posts",
+        label: "Blog Posts",
+        provider: "internal",
+        schema: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string", title: "Title" },
+              content: { type: "string", title: "Content" },
+              author: { type: "string", title: "Author" }
+            },
+            required: ["title", "content", "author"],
+            title: "Blog Post",
+            examples: [
+              {
+                title: "My First Blog Post",
+                content: "This is the content of my first blog post.",
+                author: "John Doe"
+              },
+              {
+                title: "Exploring the Cosmos",
+                content: "A journey through the stars and galaxies.",
+                author: "Jane Smith"
+              },
+              {
+                title: "The Art of Cooking",
+                content: "Delicious recipes and cooking tips.",
+                author: "Alice Johnson"
+              },
+              {
+                title: "Traveling the World",
+                content: "My adventures in different countries.",
+                author: "Bob Brown"
+              },
+              {
+                title: "Technology Trends",
+                content: "The latest trends in technology.",
+                author: "Charlie Davis"
+              }
+            ]
+          }
+        },
+        indexes: [
+          {
+            name: "idx_blog_posts_title",
+            fields: ["title"],
+            unique: true
+          }
+        ]
+      }
+    ]
+  }
+);
+var datasourceManifest = datasourceInternalManifest;
+var datasourceManifestLLM = toLLMSchema(datasourceManifest);
+var datasourcesList = Type.Array(datasourceManifest);
+var stringFilter = Type.Object({
+  field: Type.String(),
+  op: Type.Union([
+    Type.Literal("eq"),
+    Type.Literal("ne"),
+    Type.Literal("contains"),
+    Type.Literal("notContains"),
+    Type.Literal("startsWith"),
+    Type.Literal("notStartsWith"),
+    Type.Literal("endsWith"),
+    Type.Literal("notEndsWith")
+  ]),
+  value: Type.String()
+});
+var numberFilter = Type.Object({
+  field: Type.String(),
+  op: Type.Union([
+    Type.Literal("eq"),
+    Type.Literal("ne"),
+    Type.Literal("lt"),
+    Type.Literal("lte"),
+    Type.Literal("gt"),
+    Type.Literal("gte")
+  ]),
+  value: Type.Number()
+});
+var dateFilterAbsolute = Type.Object({
+  field: Type.String(),
+  op: Type.Union([Type.Literal("before"), Type.Literal("after")]),
+  value: Type.String()
+});
+var dateFilterRelative = Type.Object({
+  field: Type.String(),
+  op: Type.Union([Type.Literal("beforeNow"), Type.Literal("afterNow")]),
+  value: Type.Null()
+});
+var arrayFilter = Type.Object({
+  field: Type.String(),
+  op: Type.Union([
+    Type.Literal("contains"),
+    Type.Literal("notContains"),
+    Type.Literal("containsAll"),
+    Type.Literal("containsAny"),
+    Type.Literal("notContainsAny")
+  ]),
+  value: Type.Array(Type.String())
+});
+var booleanFilter = Type.Object({
+  field: Type.String(),
+  op: Type.Literal("eq"),
+  value: Type.Boolean()
+});
+var queryFilter = Type.Union([
+  stringFilter,
+  numberFilter,
+  dateFilterAbsolute,
+  dateFilterRelative,
+  arrayFilter,
+  booleanFilter
+]);
+var filterExpression = Type.Recursive(
+  (This) => Type.Union(
+    [
+      Type.Object({
+        op: Type.Literal("and"),
+        fields: Type.Array(Type.Union([queryFilter, This]), { title: "Indexed Fields" })
+      }),
+      Type.Object({
+        op: Type.Literal("or"),
+        fields: Type.Array(Type.Union([queryFilter, This]))
+      })
+    ],
+    {
+      default: {
+        op: "and",
+        fields: []
+      },
+      examples: [
+        {
+          op: "and",
+          fields: [
+            {
+              field: "$id",
+              op: "eq",
+              value: "123"
+            },
+            {
+              field: "$publicationDate",
+              op: "beforeNow"
+            }
+          ]
+        }
+      ]
+    }
+  ),
+  {
+    title: "Filter Expression",
+    description: "Expression used to filter query results. Can be a combination of and/or conditions."
+  }
+);
+var querySchema = Type.Object(
+  {
+    id: Type.String({
+      title: "Query ID",
+      description: "Unique identifier for the query. Used to reference the query in the system. URL-safe string like a slug."
+    }),
+    label: Type.String({
+      title: "Label",
+      maxLength: 100,
+      description: "Label of the query displayed in the UI"
+    }),
+    datasourceId: Type.String({
+      title: "Database",
+      description: "ID of the datasource to query"
+    }),
+    limit: Type.Number({
+      title: "Limit",
+      description: "Limit the number of records to fetch from the datasource.",
+      minimum: 1,
+      default: 10
+    }),
+    sortDirection: Type.Optional(
+      StringEnum(["asc", "desc"], {
+        title: "Sort",
+        enumNames: ["Ascending", "Descending"],
+        description: "Direction to sort the records by",
+        default: "desc"
+      })
+    ),
+    sortField: Type.Optional(
+      Type.String({
+        title: "Sort Field",
+        description: "Field to sort by (must be an indexed field)",
+        default: "$publicationDate"
+      })
+    ),
+    filters: Type.Optional(filterExpression),
+    parameters: Type.Optional(
+      Type.Array(
+        Type.Object({
+          field: Type.String({ title: "Field", description: "Field name to use as parameter" }),
+          op: Type.Union(
+            [
+              Type.Literal("eq"),
+              Type.Literal("ne"),
+              Type.Literal("contains"),
+              Type.Literal("notContains"),
+              Type.Literal("startsWith"),
+              Type.Literal("notStartsWith"),
+              Type.Literal("endsWith"),
+              Type.Literal("notEndsWith"),
+              Type.Literal("lt"),
+              Type.Literal("lte"),
+              Type.Literal("gt"),
+              Type.Literal("gte"),
+              Type.Literal("before"),
+              Type.Literal("after"),
+              Type.Literal("beforeNow"),
+              Type.Literal("afterNow"),
+              Type.Literal("containsAll"),
+              Type.Literal("containsAny"),
+              Type.Literal("notContainsAny")
+            ],
+            { title: "Operator", description: "Operator to use for the parameter" }
+          )
+        }),
+        {
+          title: "Parameters",
+          description: "Field name and operator that will be used as parameters when using the query in pages. Only indexed fields can be used as parameters.",
+          default: [],
+          examples: [
+            [{ field: "$slug", op: "eq" }],
+            [{ field: "category", op: "eq" }],
+            [{ field: "tags", op: "containsAny" }],
+            [{ field: "author", op: "eq" }],
+            [{ field: "title", op: "contains" }]
+          ]
+        }
+      )
+    )
+  },
+  {
+    examples: [
+      {
+        id: "latest-posts",
+        label: "Latest posts",
+        datasourceId: "blog_posts",
+        limit: 5,
+        sortDirection: "desc",
+        sortField: "$publicationDate"
+      },
+      {
+        id: "posts-by-category",
+        label: "Posts by category",
+        datasourceId: "blog_posts",
+        limit: 10,
+        sortDirection: "desc",
+        sortField: "$publicationDate",
+        parameters: [{ field: "category", op: "eq" }]
+      },
+      {
+        id: "posts-by-tag",
+        label: "Posts by tag",
+        datasourceId: "blog_posts",
+        limit: 10,
+        sortDirection: "desc",
+        sortField: "$publicationDate",
+        parameters: [{ field: "tags", op: "containsAny" }]
+      },
+      {
+        id: "author-posts",
+        label: "Author posts",
+        datasourceId: "blog_posts",
+        limit: 10,
+        sortDirection: "desc",
+        sortField: "$publicationDate",
+        parameters: [{ field: "author", op: "eq" }]
+      },
+      {
+        id: "search-posts",
+        label: "Search posts",
+        datasourceId: "blog_posts",
+        limit: 10,
+        sortDirection: "desc",
+        sortField: "$publicationDate",
+        parameters: [{ field: "title", op: "contains" }]
+      }
+    ]
+  }
+);
+
+// src/shared/bricks/props/dynamic.ts
+function queryUse() {
+  return Type2.Object(
+    {
+      queryId: Type2.String({
+        description: "The Site Query ID to use."
+      }),
+      alias: Type2.String({
+        title: "Alias",
+        minLength: 1,
+        maxLength: 100,
+        pattern: "^[a-zA-Z0-9_]+$",
+        description: "Alias for the query results, used in dynamic content. Use a simple keyword without spaces or special characters. Aliases are unique across the page.",
+        "ai:instructions": "Use a simple keyword without spaces or special characters. Aliases are unique across the page. You can use the same query several times with different aliases in order to, for example, apply different parameters to the same query."
+      }),
+      params: Type2.Optional(
+        Type2.Array(queryFilter, {
+          description: "Additional query parameters/filters to apply to the query. One can use placeholders in values like ':slug' to reference URL parameters.",
+          title: "Query Parameters",
+          default: []
+        })
+      )
+    },
+    {
+      title: "Query",
+      description: "When set, this brick will loop through the results of the query and render the content for each item.",
+      // $id: "content:queryUse",
+      "ui:field": "query",
+      metadata: {
+        category: "content"
+      },
+      examples: [
+        { queryId: "get-latest-posts", alias: "latestPosts" },
+        {
+          queryId: "get-user-profile",
+          alias: "userProfile",
+          params: [{ field: "userId", op: "eq", value: ":slug" }]
+        },
+        {
+          queryId: "get-posts-by-category",
+          alias: "postsByCategory",
+          params: [{ field: "category", op: "eq", value: ":slug" }]
+        }
+      ]
+    }
+  );
+}
+var queryUseSchema = queryUseRef();
+function queryUseRef(options = {}) {
+  return typedRef("content:queryUse", options);
+}
+function loop(options = {}) {
+  return Type2.Object(
+    {
+      over: Type2.String({
+        title: "Over",
+        description: "The query alias to loop over. If not set, the brick will be rendered only once.",
+        "ai:instructions": "Specify the Query Alias to loop over the results."
+      }),
+      overrideLimit: Type2.Optional(
+        Type2.Number({
+          minimum: 1,
+          description: "Override the limit of items to loop through. If not set, it will use the default limit of the query. If set to 1, it will not loop and will render only the first item."
+        })
+      )
+    },
+    {
+      // $id: "content:loop",
+      title: "Repeat over",
+      description: "Repeat this brick for each item in the specified query results.",
+      "ui:field": "loop",
+      "ui:hidden-if": "no-page-queries",
+      metadata: {
+        category: "content"
+      },
+      examples: [
+        {
+          over: "latestBlogPosts",
+          overrideLimit: 5
+        },
+        {
+          over: "featuredProducts",
+          overrideLimit: 3
+        },
+        {
+          over: "popularProducts"
+        }
+      ],
+      ...options
+    }
+  );
+}
+function loopRef(options = {}) {
+  return typedRef("content:loop", options);
+}
+
+// src/shared/utils/schema-registry.ts
+var schemaRegistry = /* @__PURE__ */ new Map();
+function registerSchema(id, schema) {
+  schemaRegistry.set(id, schema);
+}
+function unregisterSchema(id) {
+  schemaRegistry.delete(id);
+}
+registerSchema("styles:background", background());
+registerSchema("styles:backgroundColor", backgroundColor());
+registerSchema("styles:justifyContent", justifyContent());
+registerSchema("styles:alignItems", alignItems());
+registerSchema("styles:alignSelf", alignSelf());
+registerSchema("styles:rounding", rounding());
+registerSchema("styles:fontSize", fontSize());
+registerSchema("styles:hidden", hidden());
+registerSchema("styles:direction", direction());
+registerSchema("styles:border", border());
+registerSchema("styles:color", color());
+registerSchema("styles:borderColor", borderColor());
+registerSchema("styles:shadow", shadow());
+registerSchema("styles:textShadow", textShadow());
+registerSchema("styles:cssLength", cssLength());
+registerSchema("assets:image", image());
+registerSchema("assets:icon", icon());
+registerSchema("content:text", textContent());
+registerSchema("content:urlOrPageId", urlOrPageId());
+registerSchema("content:loop", loop());
+registerSchema("content:queryUse", queryUse());
+registerSchema("presets:color", colorPreset());
+registerSchema("content:tags", tags());
+function consolidateRefs() {
+  function resolveRefs(schema, visited = /* @__PURE__ */ new Set()) {
+    if (!schema || typeof schema !== "object" || visited.has(schema)) return schema;
+    visited.add(schema);
+    if ("$ref" in schema && typeof schema.$ref === "string") {
+      const refSchema = schemaRegistry.get(schema.$ref);
+      if (refSchema) {
+        return resolveRefs(refSchema, visited);
+      }
+    }
+    for (const key of Object.keys(schema)) {
+      const value = schema[key];
+      if (Array.isArray(value)) {
+        schema[key] = value.map((item) => resolveRefs(item, visited));
+      } else if (typeof value === "object" && value !== null) {
+        schema[key] = resolveRefs(value, visited);
+      }
+    }
+    return schema;
+  }
+  for (const [id, schema] of schemaRegistry.entries()) {
+    schemaRegistry.set(id, resolveRefs(schema));
+  }
+}
+consolidateRefs();
+
+export {
+  schemaRegistry,
+  registerSchema,
+  unregisterSchema,
+  toLLMSchema,
+  inlineSchemaRefs,
+  providersSchema,
+  datasourceManifest,
+  datasourceManifestLLM,
+  datasourcesList,
+  queryFilter,
+  querySchema,
+  queryUse,
+  queryUseSchema,
+  queryUseRef,
+  loop,
+  loopRef
+};
+//# sourceMappingURL=chunk-BW6EFRSF.js.map