@dxos/plugin-magazine 0.0.0

package/dist/lib/neutral/chunk-AFPBWBTK.mjs

@@ -0,0 +1,591 @@
+import {
+  decodeEntities,
+  makeSnippet
+} from "./chunk-APQRTYT3.mjs";
+
+// src/operations/sources/cors.ts
+var CORS_PROXY = "/api/rss?url=";
+var browserCorsProxy = () => typeof window !== "undefined" ? CORS_PROXY : void 0;
+var applyCorsProxy = (url, proxy) => proxy ? `${proxy}${encodeURIComponent(url)}` : url;
+
+// src/operations/extraction/article.ts
+import Defuddle from "defuddle/full";
+var isDocumentParserAvailable = () => typeof DOMParser !== "undefined";
+var collectImageUrls = (lead, contentHtml) => {
+  const seen = /* @__PURE__ */ new Set();
+  const urls = [];
+  const push = (url) => {
+    if (!url || url.startsWith("data:") || seen.has(url)) {
+      return;
+    }
+    seen.add(url);
+    urls.push(url);
+  };
+  push(lead);
+  const imgRegex = /<img\b[^>]+src=["']([^"']+)["']/gi;
+  let match;
+  while ((match = imgRegex.exec(contentHtml)) != null) {
+    push(match[1]);
+  }
+  return urls;
+};
+var CHROME_CLASS_PATTERN = /(?:^|[\s_-])(?:tag|topic|related|recirc|footer|sidebar|widget|share|social|comments?|disqus|recommend|more[-_]from|read[-_]next|outbrain|taboola)(?:[\s_-]|$)/i;
+var CHROME_HREF_PATTERN = /\/(?:tags?|topics?|categor(?:y|ies)|authors?|related|recommended)\//i;
+var isHeading = (el) => /^H[1-6]$/i.test(el.tagName);
+var isLinkOnlyList = (el) => {
+  if (el.tagName !== "UL" && el.tagName !== "OL") {
+    return false;
+  }
+  const items = Array.from(el.children).filter((child) => child.tagName === "LI");
+  if (items.length === 0) {
+    return false;
+  }
+  return items.every((li) => {
+    const links = li.querySelectorAll("a");
+    if (links.length !== 1) {
+      return false;
+    }
+    const text2 = (li.textContent ?? "").trim();
+    const linkText = (links[0].textContent ?? "").trim();
+    return text2.length > 0 && Math.abs(text2.length - linkText.length) <= 4;
+  });
+};
+var isTagURLBlock = (el) => {
+  const links = Array.from(el.querySelectorAll("a[href]"));
+  if (links.length < 2) {
+    return false;
+  }
+  const matching = links.filter((anchor) => CHROME_HREF_PATTERN.test(anchor.getAttribute("href") ?? ""));
+  return matching.length / links.length > 0.6;
+};
+var hasNoBodyContent = (el) => el.querySelector("p, blockquote, pre, code, figure, img, table") == null;
+var isChromeElement = (el) => {
+  const tag = el.tagName;
+  if (tag === "ASIDE" || tag === "NAV" || tag === "FOOTER") {
+    return true;
+  }
+  const role = el.getAttribute("role");
+  if (role === "navigation" || role === "complementary" || role === "contentinfo") {
+    return true;
+  }
+  if (isLinkOnlyList(el)) {
+    return true;
+  }
+  if (!hasNoBodyContent(el)) {
+    return false;
+  }
+  if (isTagURLBlock(el)) {
+    return true;
+  }
+  const classNameAndId = `${(el.getAttribute("class") ?? "").toString()} ${el.id ?? ""}`;
+  if (CHROME_CLASS_PATTERN.test(classNameAndId)) {
+    return true;
+  }
+  return false;
+};
+var findContentRoot = (doc) => doc.querySelector("article") ?? doc.querySelector("main") ?? doc.querySelector('[role="main"]') ?? doc.body;
+var pruneChromeDescendants = (root) => {
+  const candidates = Array.from(root.querySelectorAll("*"));
+  for (const el of candidates) {
+    if (!root.contains(el)) {
+      continue;
+    }
+    if (isChromeElement(el)) {
+      el.remove();
+    }
+  }
+};
+var trimDanglingTrailingHeading = (root) => {
+  let cursor = root.lastElementChild;
+  while (cursor && isHeading(cursor) && cursor.nextElementSibling == null) {
+    const previous = cursor.previousElementSibling;
+    cursor.remove();
+    cursor = previous;
+  }
+};
+var pruneTrailingChrome = (doc) => {
+  const root = findContentRoot(doc);
+  if (!root) {
+    return;
+  }
+  const originalLastChild = root.lastElementChild;
+  pruneChromeDescendants(root);
+  if (originalLastChild && !root.contains(originalLastChild)) {
+    trimDanglingTrailingHeading(root);
+  }
+};
+var mapResult = (result) => {
+  const lead = result.image || void 0;
+  return {
+    markdown: result.contentMarkdown ?? "",
+    html: result.content ?? "",
+    title: result.title || void 0,
+    author: result.author || void 0,
+    description: result.description || void 0,
+    published: result.published || void 0,
+    image: lead,
+    domain: result.domain || void 0,
+    imageUrls: collectImageUrls(lead, result.content ?? ""),
+    wordCount: result.wordCount
+  };
+};
+var extractArticle = async (html, url) => {
+  if (!html) {
+    return {
+      markdown: "",
+      html: "",
+      imageUrls: []
+    };
+  }
+  if (isDocumentParserAvailable()) {
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    pruneTrailingChrome(doc);
+    return mapResult(new Defuddle(doc, {
+      url,
+      separateMarkdown: true
+    }).parse());
+  }
+  const { Defuddle: DefuddleNode } = await import("defuddle/node");
+  return mapResult(await DefuddleNode(html, url, {
+    separateMarkdown: true
+  }));
+};
+
+// src/operations/sources/article.ts
+var FETCH_TIMEOUT_MS = 1e4;
+var MAX_RESPONSE_BYTES = 2e6;
+var MAX_RESPONSE_BYTES_HEADER = 5e6;
+var BLOCKED_HOSTS = /* @__PURE__ */ new Set([
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "::1",
+  "169.254.169.254",
+  "metadata.google.internal"
+]);
+var validateUrl = (link) => {
+  const url = new URL(link);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Unsupported protocol: ${url.protocol}`);
+  }
+  const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (BLOCKED_HOSTS.has(host)) {
+    throw new Error(`Blocked host: ${host}`);
+  }
+  return url;
+};
+var readCapped = async (response, limit) => {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body stream unavailable.");
+  }
+  const decoder = new TextDecoder("utf-8");
+  let received = 0;
+  let out = "";
+  while (received < limit) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      received += value.byteLength;
+      out += decoder.decode(value, {
+        stream: true
+      });
+    }
+  }
+  try {
+    await reader.cancel();
+  } catch {
+  }
+  return (out + decoder.decode()).slice(0, limit);
+};
+var fetchArticle = async (link, options = {}) => {
+  try {
+    const url = validateUrl(link);
+    const fetchTarget = applyCorsProxy(url.toString(), options.corsProxy);
+    const response = await fetch(fetchTarget, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      redirect: "follow"
+    });
+    if (!response.ok) {
+      throw new Error(`Fetch failed: ${response.status} ${response.statusText}`);
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && Number(contentLength) > MAX_RESPONSE_BYTES_HEADER) {
+      throw new Error(`Response too large: ${contentLength} bytes`);
+    }
+    const html = await readCapped(response, MAX_RESPONSE_BYTES);
+    const article = await extractArticle(html, url.toString());
+    return {
+      text: article.markdown,
+      imageUrls: article.imageUrls
+    };
+  } catch (error) {
+    throw new Error(`Failed to fetch article: ${String(error)}`, {
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+};
+
+// src/operations/sources/rss.ts
+import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
+import * as Effect2 from "effect/Effect";
+import { XMLParser } from "fast-xml-parser";
+import { normalizeText } from "@dxos/markdown";
+import { Subscription } from "#types";
+
+// src/operations/sources/feed-fetcher.ts
+import * as Data from "effect/Data";
+var FeedFetchError = class extends Data.TaggedError("FeedFetchError") {
+};
+
+// src/operations/sources/http.ts
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+var retryPolicy = Schedule.exponential("500 millis").pipe(Schedule.compose(Schedule.recurs(2)));
+var getJson = (schema, url, proxy) => HttpClientRequest.get(applyCorsProxy(url, proxy)).pipe(HttpClient.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(schema)), Effect.timeout("10 seconds"), Effect.retry(retryPolicy), Effect.scoped, Effect.mapError((cause) => new FeedFetchError({
+  message: `Fetch failed: ${url}`,
+  cause
+})));
+var getText = (url, proxy) => HttpClientRequest.get(applyCorsProxy(url, proxy)).pipe(HttpClient.execute, Effect.flatMap((response) => response.text), Effect.timeout("10 seconds"), Effect.retry(retryPolicy), Effect.scoped, Effect.mapError((cause) => new FeedFetchError({
+  message: `Fetch failed: ${url}`,
+  cause
+})));
+
+// src/operations/sources/rss.ts
+var stripCdata = (value) => value.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1");
+var text = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return decodeEntities(stripCdata(value));
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "object") {
+    const t = value["#text"];
+    if (typeof t === "string") {
+      return decodeEntities(stripCdata(t));
+    }
+    if (typeof t === "number" || typeof t === "boolean") {
+      return String(t);
+    }
+  }
+  return void 0;
+};
+var markdown = (value) => value != null ? normalizeText(value) : void 0;
+var fetchRss = (url, options) => Effect2.gen(function* () {
+  const xml = yield* getText(url, options?.corsProxy);
+  return yield* Effect2.try({
+    try: () => parseFeed(url, xml),
+    catch: (cause) => new FeedFetchError({
+      message: `Unrecognized feed format: ${url}`,
+      cause
+    })
+  });
+}).pipe(Effect2.provide(FetchHttpClient.layer));
+var parseFeed = (url, xml) => {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    // RSS/Atom feeds frequently embed HTML (sometimes un-escaped, without CDATA) in content fields,
+    // which can blow past fast-xml-parser's default 100-tag nesting cap.
+    maxNestedTags: 1e4,
+    // Treat known HTML-bearing fields as opaque text so embedded markup isn't parsed as XML.
+    stopNodes: [
+      "*.description",
+      "*.summary",
+      "*.content",
+      "*.content:encoded"
+    ]
+  });
+  const parsed = parser.parse(xml);
+  const channel = parsed.rss?.channel ?? parsed.feed;
+  if (!channel) {
+    throw new Error("Unrecognized feed format");
+  }
+  const isAtom = !parsed.rss;
+  const feedName = text(channel.title) ?? "";
+  const feedDescription = markdown(text(isAtom ? channel.subtitle : channel.description)) ?? "";
+  const items = (isAtom ? channel.entry : channel.item) ?? [];
+  const itemList = Array.isArray(items) ? items : [
+    items
+  ];
+  const posts = itemList.map((item) => {
+    const link = isAtom ? (Array.isArray(item.link) ? item.link.find((l) => l["@_rel"] === "alternate")?.["@_href"] : item.link?.["@_href"] ?? text(item.link)) ?? "" : text(item.link) ?? "";
+    const author = isAtom ? text(item.author?.name) ?? text(item.author) : text(item["dc:creator"]) ?? text(item.author);
+    const description = markdown(text(item.description));
+    const content = isAtom ? markdown(text(item.summary)) ?? markdown(text(item.content)) : markdown(text(item["content:encoded"]));
+    return Subscription.makePost({
+      title: text(item.title),
+      link,
+      description,
+      content,
+      author,
+      published: text(item.pubDate) ?? text(item.published) ?? text(item.updated),
+      guid: (isAtom ? text(item.id) : text(item.guid)) ?? link
+    });
+  });
+  const feed = Subscription.makeSubscription({
+    name: feedName,
+    url,
+    description: feedDescription
+  });
+  return {
+    feed,
+    posts
+  };
+};
+
+// src/operations/sources/standard-site.ts
+import * as FetchHttpClient2 from "@effect/platform/FetchHttpClient";
+import * as Effect3 from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Subscription as Subscription2 } from "#types";
+var BSKY_PUBLIC_API = "https://public.api.bsky.app/xrpc";
+var PLC_DIRECTORY = "https://plc.directory";
+var DOCUMENT_COLLECTION = "site.standard.document";
+var MARKDOWN_CONTENT_TYPE = "site.standard.content.markdown";
+var endpoints = {
+  resolveHandle: (handle) => `${BSKY_PUBLIC_API}/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`,
+  getProfile: (actor) => `${BSKY_PUBLIC_API}/app.bsky.actor.getProfile?actor=${encodeURIComponent(actor)}`,
+  searchActors: (query, limit) => `${BSKY_PUBLIC_API}/app.bsky.actor.searchActorsTypeahead?q=${encodeURIComponent(query)}&limit=${limit}`,
+  plcDoc: (did) => `${PLC_DIRECTORY}/${did}`,
+  listRecords: (pds, did, collection, limit) => `${pds}/xrpc/com.atproto.repo.listRecords?repo=${encodeURIComponent(did)}&collection=${encodeURIComponent(collection)}&limit=${limit}`,
+  getRecord: (pds, did, collection, rkey) => `${pds}/xrpc/com.atproto.repo.getRecord?repo=${encodeURIComponent(did)}&collection=${encodeURIComponent(collection)}&rkey=${encodeURIComponent(rkey)}`
+};
+var parseStandardSiteActor = (url) => {
+  const match = url.match(/bsky\.app\/profile\/([^/?#]+)/);
+  if (match) {
+    return match[1];
+  }
+  return url.replace(/^@/, "").trim();
+};
+var listStandardSitePublications = (actorOrUrl, options) => Effect3.gen(function* () {
+  const proxy = options?.corsProxy;
+  const actor = parseStandardSiteActor(actorOrUrl);
+  const did = yield* resolveDid(actor, proxy);
+  const pds = yield* resolvePds(did, proxy);
+  const records = yield* listDocuments(pds, did, proxy);
+  const sites = distinct(records.map((record) => record.value.site).filter(isString));
+  return yield* Effect3.forEach(sites, (site) => resolvePublication(site, proxy).pipe(Effect3.catchAll(() => Effect3.succeed({
+    site
+  }))), {
+    concurrency: "unbounded"
+  });
+}).pipe(Effect3.provide(FetchHttpClient2.layer));
+var searchStandardSiteHandles = (query, options) => query.trim().length === 0 ? Effect3.succeed([]) : getJson(SearchActorsResponse, endpoints.searchActors(query.trim(), 8), options?.corsProxy).pipe(Effect3.map((response) => (response.actors ?? []).map((actor) => ({
+  handle: actor.handle,
+  displayName: actor.displayName
+}))), Effect3.orElseSucceed(() => []), Effect3.provide(FetchHttpClient2.layer));
+var fetchStandardSite = (url, options) => Effect3.gen(function* () {
+  const proxy = options?.corsProxy;
+  const did = yield* resolveDidFromSite(url, proxy);
+  const pds = yield* resolvePds(did, proxy);
+  const allRecords = yield* listDocuments(pds, did, proxy);
+  const records = allRecords.filter((record) => record.value.site === url);
+  const profile = yield* fetchProfile(did, proxy);
+  const authorName = profile?.displayName ?? profile?.handle ?? did;
+  const publication = yield* resolvePublication(url, proxy).pipe(Effect3.catchAll(() => Effect3.succeed({
+    site: url
+  })));
+  const posts = records.map((record) => {
+    const value = record.value;
+    const content = value.content?.$type === MARKDOWN_CONTENT_TYPE ? value.content.text : void 0;
+    const description = value.description ?? (value.textContent ? makeSnippet(value.textContent) : void 0);
+    return Subscription2.makePost({
+      title: value.title,
+      link: joinUrl(publication.url, value.path),
+      description,
+      content,
+      author: authorName,
+      published: value.publishedAt,
+      // The record's AT-URI is the stable dedup key (see `sync-feed.ts` `postKey`).
+      guid: record.uri
+    });
+  });
+  posts.sort((postA, postB) => (postB.published ?? "").localeCompare(postA.published ?? ""));
+  const feed = Subscription2.makeSubscription({
+    name: publication.name ?? authorName,
+    url,
+    description: profile?.description ?? `Standard.site articles from @${profile?.handle ?? did}`,
+    iconUrl: profile?.avatar,
+    type: "standard-site"
+  });
+  return {
+    feed,
+    posts
+  };
+}).pipe(Effect3.provide(FetchHttpClient2.layer));
+var ResolveHandleResponse = Schema.Struct({
+  did: Schema.optional(Schema.String)
+});
+var SearchActorsResponse = Schema.Struct({
+  actors: Schema.optional(Schema.Array(Schema.Struct({
+    handle: Schema.String,
+    displayName: Schema.optional(Schema.String)
+  })))
+});
+var DidDocument = Schema.Struct({
+  service: Schema.optional(Schema.Array(Schema.Struct({
+    id: Schema.optional(Schema.String),
+    type: Schema.optional(Schema.String),
+    serviceEndpoint: Schema.optional(Schema.String)
+  })))
+});
+var Profile = Schema.Struct({
+  handle: Schema.optional(Schema.String),
+  displayName: Schema.optional(Schema.String),
+  avatar: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String)
+});
+var StandardSiteDocument = Schema.Struct({
+  site: Schema.optional(Schema.String),
+  title: Schema.optional(Schema.String),
+  publishedAt: Schema.optional(Schema.String),
+  path: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  content: Schema.optional(Schema.Struct({
+    $type: Schema.optional(Schema.String),
+    text: Schema.optional(Schema.String)
+  })),
+  textContent: Schema.optional(Schema.String)
+});
+var ListRecordsResponse = Schema.Struct({
+  records: Schema.optional(Schema.Array(Schema.Struct({
+    uri: Schema.String,
+    value: StandardSiteDocument
+  }))),
+  cursor: Schema.optional(Schema.String)
+});
+var PublicationRecord = Schema.Struct({
+  value: Schema.optional(Schema.Struct({
+    url: Schema.optional(Schema.String),
+    name: Schema.optional(Schema.String)
+  }))
+});
+var resolveDidFromSite = (site, proxy) => {
+  if (site.startsWith("at://")) {
+    const parsed = parseAtUri(site);
+    return parsed ? Effect3.succeed(parsed.did) : Effect3.fail(new FeedFetchError({
+      message: `Malformed at:// site reference: ${site}`
+    }));
+  }
+  if (site.startsWith("https://")) {
+    const { hostname } = new URL(site);
+    return getJson(Schema.Struct({
+      did: Schema.optional(Schema.String)
+    }), `https://${hostname}/.well-known/atproto-did`, proxy).pipe(Effect3.flatMap((result) => result.did ? Effect3.succeed(result.did) : Effect3.fail(new FeedFetchError({
+      message: `No atproto DID found at ${hostname}/.well-known/atproto-did`
+    }))));
+  }
+  return Effect3.fail(new FeedFetchError({
+    message: `Cannot resolve DID from site reference: ${site}`
+  }));
+};
+var resolveDid = (actor, proxy) => actor.startsWith("did:") ? Effect3.succeed(actor) : getJson(ResolveHandleResponse, endpoints.resolveHandle(actor), proxy).pipe(Effect3.flatMap((resolved) => resolved.did ? Effect3.succeed(resolved.did) : Effect3.fail(new FeedFetchError({
+  message: `Could not resolve handle to DID: ${actor}`
+}))));
+var resolvePds = (did, proxy) => {
+  if (did.startsWith("did:plc:")) {
+    return getJson(DidDocument, endpoints.plcDoc(did), proxy).pipe(Effect3.flatMap((doc) => extractPds(doc, did)));
+  }
+  if (did.startsWith("did:web:")) {
+    const [host, ...segments] = did.slice("did:web:".length).split(":").map((segment) => decodeURIComponent(segment));
+    if (!host) {
+      return Effect3.fail(new FeedFetchError({
+        message: `Invalid did:web identifier: ${did}`
+      }));
+    }
+    const path = segments.length > 0 ? `/${segments.join("/")}/did.json` : "/.well-known/did.json";
+    return getJson(DidDocument, `https://${host}${path}`, proxy).pipe(Effect3.flatMap((doc) => extractPds(doc, did)));
+  }
+  return Effect3.fail(new FeedFetchError({
+    message: `Unsupported DID method: ${did}`
+  }));
+};
+var extractPds = (doc, did) => {
+  const service = doc.service?.find((entry) => entry.id === "#atproto_pds" || entry.type === "AtprotoPersonalDataServer");
+  const endpoint = service?.serviceEndpoint;
+  return typeof endpoint === "string" && endpoint.length > 0 ? Effect3.succeed(endpoint.replace(/\/$/, "")) : Effect3.fail(new FeedFetchError({
+    message: `No PDS endpoint found for DID: ${did}`
+  }));
+};
+var listDocuments = (pds, did, proxy) => Effect3.gen(function* () {
+  const all = [];
+  let cursor;
+  do {
+    const url = endpoints.listRecords(pds, did, DOCUMENT_COLLECTION, 100) + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : "");
+    const page = yield* getJson(ListRecordsResponse, url, proxy);
+    all.push(...page.records ?? []);
+    cursor = page.cursor;
+  } while (cursor);
+  return all;
+});
+var fetchProfile = (actor, proxy) => getJson(Profile, endpoints.getProfile(actor), proxy).pipe(Effect3.catchAll(() => Effect3.succeed(void 0)));
+var resolvePublication = (site, proxy) => {
+  if (site.startsWith("http")) {
+    return Effect3.succeed({
+      site,
+      url: site.replace(/\/$/, "")
+    });
+  }
+  if (site.startsWith("at://")) {
+    const parsed = parseAtUri(site);
+    if (!parsed) {
+      return Effect3.succeed({
+        site
+      });
+    }
+    return Effect3.gen(function* () {
+      const pds = yield* resolvePds(parsed.did, proxy);
+      const record = yield* getJson(PublicationRecord, endpoints.getRecord(pds, parsed.did, parsed.collection, parsed.rkey), proxy);
+      const value = record.value ?? {};
+      return {
+        site,
+        url: value.url ? value.url.replace(/\/$/, "") : void 0,
+        name: value.name
+      };
+    });
+  }
+  return Effect3.succeed({
+    site
+  });
+};
+var parseAtUri = (uri) => {
+  const match = uri.match(/^at:\/\/([^/]+)\/([^/]+)\/([^/]+)$/);
+  return match ? {
+    did: match[1],
+    collection: match[2],
+    rkey: match[3]
+  } : void 0;
+};
+var joinUrl = (base, path) => {
+  if (!base) {
+    return void 0;
+  }
+  if (!path) {
+    return base;
+  }
+  return `${base}${path.startsWith("/") ? "" : "/"}${path}`;
+};
+var isString = (value) => typeof value === "string";
+var distinct = (values) => [
+  ...new Set(values)
+];
+
+export {
+  browserCorsProxy,
+  fetchArticle,
+  fetchRss,
+  listStandardSitePublications,
+  searchStandardSiteHandles,
+  fetchStandardSite
+};
+//# sourceMappingURL=chunk-AFPBWBTK.mjs.map