katecms 0.0.0-stage → 1.0.0-beta.1

package/dist/runtime/server/utils/dictionaries.d.ts

@@ -0,0 +1,53 @@
+import type { Database, Dictionaries, Dictionary, DictionaryDefinition } from '@katecms/core';
+import type { Kysely } from 'kysely';
+import type { CollectionDictionaryPicker, PublicDictionaryTerm } from '../../utils/collections.js';
+import type { AdminDictionaryMeta, AdminDictionaryTerm, ParentOption } from '../../utils/dictionaries.js';
+import { fail, readEntryId, readFields, readParentId, readSlug, readTitle } from './collections.js';
+export { fail, readEntryId, readFields, readParentId, readSlug, readTitle };
+export declare function getDictionaries(): Dictionaries;
+export declare function getDictionaryDefinition(slug: string): DictionaryDefinition | undefined;
+export declare function requireDictionary(slug: string): DictionaryDefinition;
+export declare function toDictionaryMeta(slug: string, def: DictionaryDefinition): AdminDictionaryMeta;
+export declare function toPublicTerm(row: Dictionary, slugPath: string): PublicDictionaryTerm;
+export declare function toAdminTerm(row: Dictionary, slugPath: string, flags?: {
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    depth?: number;
+}): AdminDictionaryTerm;
+export declare function toParentOption(row: {
+    id: number;
+    title: string;
+    slug: string;
+    parent_id: number | null;
+    slugPath: string;
+    depth: number;
+}): ParentOption;
+export declare function readDictionarySlug(raw: string | undefined): string;
+export declare function requireTermFields(def: DictionaryDefinition, fields: Record<string, unknown>): void;
+export declare function listDictionaryParentOptions(rows: Array<{
+    id: number;
+    title: string;
+    slug: string;
+    parent_id: number | null;
+}>, excludeId?: number): ParentOption[];
+export declare function flattenDictionaryTerms(rows: Dictionary[]): Array<{
+    row: Dictionary;
+    depth: number;
+    slugPath: string;
+}>;
+export declare function assertDictionaryParent(rows: Array<{
+    id: number;
+    type: string;
+    parent_id: number | null;
+}>, type: string, parentId: number | null, excludeId?: number): void;
+export declare function rethrowDictionaryWriteError(error: unknown): never;
+export declare function dictionariesForCollection(collectionSlug: string): Array<{
+    slug: string;
+    def: DictionaryDefinition;
+}>;
+export declare function loadCollectionDictionaryPickers(db: Kysely<Database>, collectionSlug: string): Promise<CollectionDictionaryPicker[]>;
+/** Assigned terms for a public entry, keyed by dictionary slug (empty arrays when none). */
+export declare function loadAssignedEntryDictionaries(db: Kysely<Database>, collectionId: number, collectionSlug: string): Promise<Record<string, PublicDictionaryTerm[]>>;
+export declare function selectedDictionaryIds(db: Kysely<Database>, collectionId: number, pickers: CollectionDictionaryPicker[]): Promise<Record<string, number[]>>;
+export declare function readDictionaryAssignments(value: unknown, pickers: CollectionDictionaryPicker[]): Record<string, number[]>;
+export declare function applyDictionaryAssignments(db: Kysely<Database>, collectionId: number, collectionSlug: string, value: unknown): Promise<Record<string, number[]>>;

package/dist/runtime/server/utils/dictionaries.js

@@ -0,0 +1,301 @@
+import { useRuntimeConfig } from "#imports";
+import {
+  buildSlugPathMap,
+  flattenCollectionTree,
+  formatRequiredFieldsError,
+  isUniqueConstraintError,
+  listDictionaries,
+  listDictionariesByCollection,
+  setCollectionDictionaries,
+  validateRequiredFields
+} from "@katecms/core";
+import {
+  fail,
+  readEntryId,
+  readFields,
+  readParentId,
+  readSlug,
+  readTitle
+} from "./collections.js";
+export { fail, readEntryId, readFields, readParentId, readSlug, readTitle };
+export function getDictionaries() {
+  return useRuntimeConfig().katecms?.dictionaries ?? {};
+}
+export function getDictionaryDefinition(slug) {
+  return getDictionaries()[slug];
+}
+export function requireDictionary(slug) {
+  const dictionary = getDictionaryDefinition(slug);
+  if (!dictionary) {
+    fail(404, "Dictionary not found.");
+  }
+  return dictionary;
+}
+export function toDictionaryMeta(slug, def) {
+  return {
+    slug,
+    labels: {
+      name: def.labels.name,
+      singularName: def.labels.singularName ?? def.labels.name
+    },
+    fields: def.fields ?? {},
+    collections: [...def.collections],
+    multiple: def.multiple === true,
+    hierarchical: def.hierarchical === true,
+    public: def.public !== false,
+    rewrite: def.rewrite
+  };
+}
+function toIso(value) {
+  if (value == null) {
+    return (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? (/* @__PURE__ */ new Date(0)).toISOString() : value.toISOString();
+  }
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? (/* @__PURE__ */ new Date(0)).toISOString() : date.toISOString();
+}
+export function toPublicTerm(row, slugPath) {
+  return {
+    id: row.id,
+    type: row.type,
+    slug: row.slug,
+    slugPath: slugPath || row.slug,
+    title: row.title,
+    fields: row.fields ?? {},
+    parentId: row.parent_id
+  };
+}
+export function toAdminTerm(row, slugPath, flags) {
+  return {
+    id: row.id,
+    type: row.type,
+    slug: row.slug,
+    slugPath: slugPath || row.slug,
+    title: row.title,
+    fields: row.fields ?? {},
+    parentId: row.parent_id,
+    createdAt: toIso(row.created_at),
+    updatedAt: toIso(row.updated_at),
+    ...flags
+  };
+}
+export function toParentOption(row) {
+  return {
+    id: row.id,
+    title: row.title,
+    slug: row.slug,
+    parentId: row.parent_id,
+    slugPath: row.slugPath,
+    depth: row.depth
+  };
+}
+export function readDictionarySlug(raw) {
+  const slug = typeof raw === "string" ? raw.trim() : "";
+  if (!slug) {
+    fail(400, "Dictionary is required.");
+  }
+  return slug;
+}
+export function requireTermFields(def, fields) {
+  const issues = validateRequiredFields(def.fields ?? {}, fields);
+  if (issues.length > 0) {
+    fail(422, formatRequiredFieldsError(issues));
+  }
+}
+function descendantIds(rows, rootId) {
+  const children = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.parent_id == null) {
+      continue;
+    }
+    const list = children.get(row.parent_id) ?? [];
+    list.push(row.id);
+    children.set(row.parent_id, list);
+  }
+  const out = /* @__PURE__ */ new Set();
+  const stack = [...children.get(rootId) ?? []];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (out.has(id)) {
+      continue;
+    }
+    out.add(id);
+    stack.push(...children.get(id) ?? []);
+  }
+  return out;
+}
+export function listDictionaryParentOptions(rows, excludeId) {
+  const blocked = excludeId === void 0 ? /* @__PURE__ */ new Set() : descendantIds(rows, excludeId);
+  if (excludeId !== void 0) {
+    blocked.add(excludeId);
+  }
+  const visible = rows.filter((row) => !blocked.has(row.id));
+  const paths = buildSlugPathMap(visible);
+  return flattenCollectionTree(visible).map(({ row, depth }) => toParentOption({
+    ...row,
+    slugPath: paths.get(row.id) ?? row.slug,
+    depth
+  }));
+}
+export function flattenDictionaryTerms(rows) {
+  const paths = buildSlugPathMap(rows);
+  return flattenCollectionTree(rows).map(({ row, depth }) => ({
+    row,
+    depth,
+    slugPath: paths.get(row.id) ?? row.slug
+  }));
+}
+export function assertDictionaryParent(rows, type, parentId, excludeId) {
+  if (parentId == null) {
+    return;
+  }
+  const parent = rows.find((row) => row.id === parentId);
+  if (!parent || parent.type !== type) {
+    fail(422, "Invalid parent.");
+  }
+  if (excludeId !== void 0 && parentId === excludeId) {
+    fail(422, "Invalid parent.");
+  }
+  if (excludeId !== void 0) {
+    const blocked = descendantIds(rows, excludeId);
+    if (blocked.has(parentId)) {
+      fail(422, "Invalid parent.");
+    }
+  }
+}
+export function rethrowDictionaryWriteError(error) {
+  if (isUniqueConstraintError(error)) {
+    fail(409, "A term with this slug already exists.");
+  }
+  const message = error instanceof Error ? error.message : "";
+  if (/parent/i.test(message) || /descendant/i.test(message) || /hierarchy/i.test(message)) {
+    fail(422, message.startsWith("dictionaries:") ? "Invalid parent." : message);
+  }
+  throw error;
+}
+export function dictionariesForCollection(collectionSlug) {
+  return Object.entries(getDictionaries()).filter(([, def]) => def.collections.includes(collectionSlug)).map(([slug, def]) => ({ slug, def }));
+}
+export async function loadCollectionDictionaryPickers(db, collectionSlug) {
+  const attached = dictionariesForCollection(collectionSlug);
+  const pickers = [];
+  for (const { slug, def } of attached) {
+    const rows = await listDictionaries(db, slug);
+    pickers.push({
+      slug,
+      labels: {
+        name: def.labels.name,
+        singularName: def.labels.singularName ?? def.labels.name
+      },
+      multiple: def.multiple === true,
+      terms: listDictionaryParentOptions(rows)
+    });
+  }
+  return pickers;
+}
+export async function loadAssignedEntryDictionaries(db, collectionId, collectionSlug) {
+  const attached = dictionariesForCollection(collectionSlug);
+  const grouped = Object.fromEntries(
+    attached.map(({ slug }) => [slug, []])
+  );
+  if (attached.length === 0) {
+    return grouped;
+  }
+  const allowed = new Set(attached.map(({ slug }) => slug));
+  const linked = (await listDictionariesByCollection(db, collectionId)).filter((term) => allowed.has(term.type));
+  if (linked.length === 0) {
+    return grouped;
+  }
+  const typesNeeded = [...new Set(linked.map((term) => term.type))];
+  const typeRows = await Promise.all(typesNeeded.map((type) => listDictionaries(db, type)));
+  const pathMaps = new Map(typesNeeded.map((type, index) => [
+    type,
+    buildSlugPathMap(typeRows[index])
+  ]));
+  for (const term of linked) {
+    grouped[term.type].push(toPublicTerm(term, pathMaps.get(term.type)?.get(term.id) ?? term.slug));
+  }
+  return grouped;
+}
+export async function selectedDictionaryIds(db, collectionId, pickers) {
+  const ids = Object.fromEntries(
+    pickers.map((picker) => [picker.slug, []])
+  );
+  if (pickers.length === 0) {
+    return ids;
+  }
+  const allowed = new Set(pickers.map((picker) => picker.slug));
+  const linked = await listDictionariesByCollection(db, collectionId);
+  for (const term of linked) {
+    if (!allowed.has(term.type)) {
+      continue;
+    }
+    ids[term.type].push(term.id);
+  }
+  return ids;
+}
+function readTermIdList(value) {
+  if (value === void 0 || value === null || value === "") {
+    return [];
+  }
+  const raw = Array.isArray(value) ? value : [value];
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const id = typeof item === "number" ? item : Number(item);
+    if (!Number.isInteger(id) || id <= 0) {
+      fail(422, "Invalid dictionary term.");
+    }
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+export function readDictionaryAssignments(value, pickers) {
+  if (value === void 0 || value === null) {
+    return Object.fromEntries(pickers.map((picker) => [picker.slug, []]));
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    fail(422, "Invalid dictionary selection.");
+  }
+  const raw = value;
+  const allowed = new Set(pickers.map((picker) => picker.slug));
+  for (const slug of Object.keys(raw)) {
+    if (!allowed.has(slug)) {
+      fail(422, "Unknown dictionary.");
+    }
+  }
+  const assigned = {};
+  for (const picker of pickers) {
+    const termIds = new Set(picker.terms.map((term) => term.id));
+    const selected = readTermIdList(raw[picker.slug]);
+    for (const id of selected) {
+      if (!termIds.has(id)) {
+        fail(422, "Invalid dictionary term.");
+      }
+    }
+    if (!picker.multiple && selected.length > 1) {
+      fail(422, `Only one ${picker.labels.singularName.toLowerCase()} can be selected.`);
+    }
+    assigned[picker.slug] = selected;
+  }
+  return assigned;
+}
+export async function applyDictionaryAssignments(db, collectionId, collectionSlug, value) {
+  const pickers = await loadCollectionDictionaryPickers(db, collectionSlug);
+  if (pickers.length === 0) {
+    return {};
+  }
+  const assigned = readDictionaryAssignments(value, pickers);
+  const linked = await listDictionariesByCollection(db, collectionId);
+  const replaceTypes = new Set(pickers.map((picker) => picker.slug));
+  const keep = linked.filter((term) => !replaceTypes.has(term.type)).map((term) => term.id);
+  const next = [...keep, ...Object.values(assigned).flat()];
+  await setCollectionDictionaries(db, collectionId, next);
+  return assigned;
+}

package/dist/runtime/server/utils/media-list.d.ts

@@ -0,0 +1,18 @@
+import type { Database } from '@katecms/core';
+import { type SelectQueryBuilder } from 'kysely';
+import type { Kysely } from 'kysely';
+import type { MediaSort, MediaTypeFilter } from '../../utils/media-library-query.js';
+export interface MediaListFilter {
+    type: MediaTypeFilter;
+    /** `YYYY-MM`, or empty for every month. */
+    month: string;
+    search: string;
+    offsetMinutes: number;
+    sort: MediaSort;
+}
+type MediaQuery<T> = SelectQueryBuilder<Database, 'media', T>;
+export declare function applyMediaListFilter<T>(query: MediaQuery<T>, filter: MediaListFilter, driver: 'sqlite' | 'postgres'): MediaQuery<T>;
+/** Stable order for the paged library. Non-images stay last when sorting by pixel size. */
+export declare function applyMediaListOrder<T>(query: MediaQuery<T>, sort: MediaSort): MediaQuery<T>;
+export declare function listMediaMonths(db: Kysely<Database>, filter: MediaListFilter, driver: 'sqlite' | 'postgres'): Promise<string[]>;
+export {};

package/dist/runtime/server/utils/media-list.js

@@ -0,0 +1,84 @@
+import { sql } from "kysely";
+import {
+  ARCHIVE_MIME_TYPES,
+  DOCUMENT_MIME_TYPES,
+  SPREADSHEET_MIME_TYPES,
+  clampUtcOffsetMinutes,
+  searchNeedle
+} from "../../utils/media-library-query.js";
+function exactMimes(type) {
+  if (type === "document") {
+    return DOCUMENT_MIME_TYPES;
+  }
+  if (type === "spreadsheet") {
+    return SPREADSHEET_MIME_TYPES;
+  }
+  if (type === "archive") {
+    return ARCHIVE_MIME_TYPES;
+  }
+  return null;
+}
+function monthExpression(driver, offsetMinutes) {
+  const offset = clampUtcOffsetMinutes(offsetMinutes);
+  if (driver === "postgres") {
+    return sql`to_char((media.created_at AT TIME ZONE 'UTC') + (${offset} * interval '1 minute'), 'YYYY-MM')`;
+  }
+  const modifier = `${offset >= 0 ? "+" : ""}${offset} minutes`;
+  return sql`substr(datetime(substr(replace(replace(media.created_at, 'T', ' '), 'Z', ''), 1, 19), ${modifier}), 1, 7)`;
+}
+export function applyMediaListFilter(query, filter, driver) {
+  let next = query;
+  if (filter.type === "image" || filter.type === "audio" || filter.type === "video") {
+    next = next.where(sql`lower(media.mime_type) like ${`${filter.type}/%`}`);
+  } else {
+    const mimes = exactMimes(filter.type);
+    if (mimes) {
+      next = next.where(sql`lower(media.mime_type) in (${sql.join(mimes.map((mime) => sql`${mime}`))})`);
+    }
+  }
+  if (/^\d{4}-(0[1-9]|1[0-2])$/.test(filter.month)) {
+    const month = monthExpression(driver, filter.offsetMinutes);
+    next = next.where(sql`${month} = ${filter.month}`);
+  }
+  const needle = searchNeedle(filter.search);
+  if (needle) {
+    const pattern = `%${needle}%`;
+    next = next.where(sql`(
+      lower(media.filename) like ${pattern}
+      or lower(coalesce(media.alt, '')) like ${pattern}
+      or lower(coalesce(media.caption, '')) like ${pattern}
+    )`);
+  }
+  return next;
+}
+function sortParts(sort) {
+  const direction = sort.endsWith("-asc") ? "asc" : "desc";
+  const field = sort.slice(0, -(direction.length + 1));
+  return { field, direction };
+}
+export function applyMediaListOrder(query, sort) {
+  const { field, direction } = sortParts(sort);
+  if (field === "name") {
+    return query.orderBy(sql`lower(media.filename)`, direction).orderBy("id", "asc");
+  }
+  if (field === "filesize") {
+    return query.orderBy("filesize", direction).orderBy("id", "asc");
+  }
+  if (field === "dimensions") {
+    return query.orderBy(sql`(media.width is null or media.height is null)`).orderBy(sql`coalesce(media.width, 0) * coalesce(media.height, 0)`, direction).orderBy("id", "asc");
+  }
+  if (field === "author") {
+    const author = sql`(select lower(coalesce(nullif(trim(users.name), ''), users.email)) from users where users.id = media.uploaded_by)`;
+    return query.orderBy(sql`${author} is null`).orderBy(author, direction).orderBy("id", "asc");
+  }
+  return query.orderBy("created_at", direction).orderBy("id", direction);
+}
+export async function listMediaMonths(db, filter, driver) {
+  const month = monthExpression(driver, filter.offsetMinutes);
+  const rows = await applyMediaListFilter(
+    db.selectFrom("media"),
+    { ...filter, month: "" },
+    driver
+  ).select(month.as("month")).distinct().execute();
+  return rows.map((row) => String(row.month ?? "")).filter((value) => /^\d{4}-(0[1-9]|1[0-2])$/.test(value)).sort((a, b) => b.localeCompare(a));
+}

package/dist/runtime/server/utils/media.d.ts

@@ -0,0 +1,12 @@
+import type { H3Event } from 'h3';
+import type { Media, MediaItem, MediaStorage, ResolvedMediaConfig, StoredMediaVariant } from '@katecms/core';
+/** Public URL prefix; files in `public/uploads` are served here by Nuxt. */
+export declare const UPLOADS_PUBLIC_PATH = "/uploads";
+export declare function getMediaConfig(): ResolvedMediaConfig;
+export declare function getMediaStorage(): MediaStorage;
+export declare function toClientMedia(row: Media, uploadedByName?: string | null): MediaItem;
+export declare function parseMediaId(raw: string | undefined): number;
+export declare function storedVariants(value: unknown): StoredMediaVariant[];
+export declare function uploaderNames(ids: Array<number | null | undefined>): Promise<Map<number, string>>;
+export declare function toClientMediaRow(row: Media): Promise<MediaItem>;
+export declare function scheduleBackground(event: H3Event, task: Promise<unknown>): void;

package/dist/runtime/server/utils/media.js

@@ -0,0 +1,77 @@
+import { useRuntimeConfig } from "#imports";
+import { createError } from "h3";
+import {
+  createLocalMediaStorage,
+  findUserById,
+  toMediaItem
+} from "@katecms/core";
+import { getDb } from "./db.js";
+export const UPLOADS_PUBLIC_PATH = "/uploads";
+let storage;
+export function getMediaConfig() {
+  const media = useRuntimeConfig().katecms?.media;
+  if (!media?.dir) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Media upload directory is not configured."
+    });
+  }
+  return media;
+}
+export function getMediaStorage() {
+  if (storage) {
+    return storage;
+  }
+  storage = createLocalMediaStorage({
+    dir: getMediaConfig().dir,
+    publicPrefix: UPLOADS_PUBLIC_PATH
+  });
+  return storage;
+}
+export function toClientMedia(row, uploadedByName) {
+  return toMediaItem(row, {
+    publicUrl: (key) => getMediaStorage().publicUrl(key),
+    uploadedByName
+  });
+}
+export function parseMediaId(raw) {
+  const id = Number(raw);
+  if (!Number.isInteger(id) || id <= 0) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid id." });
+  }
+  return id;
+}
+export function storedVariants(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((row) => {
+    if (!row || typeof row !== "object") {
+      return false;
+    }
+    const variant = row;
+    return typeof variant.filename === "string" && typeof variant.size === "string" && typeof variant.format === "string";
+  });
+}
+export async function uploaderNames(ids) {
+  const unique = [...new Set(ids.filter((id) => typeof id === "number"))];
+  const names = /* @__PURE__ */ new Map();
+  const db = getDb();
+  await Promise.all(unique.map(async (id) => {
+    const user = await findUserById(db, id);
+    if (user) {
+      names.set(id, user.name?.trim() || user.email);
+    }
+  }));
+  return names;
+}
+export async function toClientMediaRow(row) {
+  const names = await uploaderNames([row.uploaded_by]);
+  return toClientMedia(row, row.uploaded_by != null ? names.get(row.uploaded_by) ?? null : null);
+}
+export function scheduleBackground(event, task) {
+  const waitUntil = event.waitUntil;
+  if (typeof waitUntil === "function") {
+    waitUntil(task);
+  }
+}

package/dist/runtime/server/utils/oembed-fetch.d.ts

@@ -0,0 +1,4 @@
+import type { OembedConnectInit } from '@katecms/core';
+export declare function resolveOembedHost(hostname: string): Promise<string[]>;
+/** Dial `address` while the request still carries `url`'s hostname. */
+export declare function connectOembed(url: URL, address: string, init: OembedConnectInit): Promise<Response>;

package/dist/runtime/server/utils/oembed-fetch.js

@@ -0,0 +1,142 @@
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+import { lookup } from "node:dns/promises";
+import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
+const MAX_BODY_BYTES = 1e6;
+const SKIP_HEADERS = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding"]);
+export async function resolveOembedHost(hostname) {
+  const host = hostname.replace(/^\[|\]$/g, "");
+  if (isIP(host)) {
+    return [host];
+  }
+  const records = await lookup(host, { all: true, verbatim: true });
+  return records.map((record) => record.address);
+}
+function pinnedLookup(address, family) {
+  return (_hostname, options, callback) => {
+    if (options.all) {
+      callback(null, [{ address, family }]);
+      return;
+    }
+    callback(null, address, family);
+  };
+}
+function responseHeaders(raw) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(raw)) {
+    if (SKIP_HEADERS.has(key) || value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  return headers;
+}
+function decodeBody(body, encoding) {
+  const maxOutputLength = MAX_BODY_BYTES;
+  const kind = encoding?.trim().toLowerCase();
+  try {
+    if (!kind || kind === "identity") {
+      return body;
+    }
+    if (kind === "gzip" || kind === "x-gzip") {
+      return gunzipSync(body, { maxOutputLength });
+    }
+    if (kind === "deflate") {
+      return inflateSync(body, { maxOutputLength });
+    }
+    if (kind === "br") {
+      return brotliDecompressSync(body, { maxOutputLength });
+    }
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : "";
+    if (code === "ERR_BUFFER_TOO_LARGE") {
+      throw new Error("oEmbed response is too large.");
+    }
+    throw new Error("Failed to fetch oEmbed.");
+  }
+  throw new Error("Failed to fetch oEmbed.");
+}
+export function connectOembed(url, address, init) {
+  const family = isIP(address);
+  if (family !== 4 && family !== 6) {
+    return Promise.reject(new Error("Failed to resolve host."));
+  }
+  const secure = url.protocol === "https:";
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  const port = url.port ? Number(url.port) : secure ? 443 : 80;
+  const options = {
+    hostname,
+    port,
+    method: "GET",
+    path: `${url.pathname}${url.search}`,
+    headers: {
+      ...init.headers,
+      "accept-encoding": "identity",
+      host: url.host
+    },
+    lookup: pinnedLookup(address, family),
+    signal: init.signal
+  };
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let tooLarge = false;
+    const fail = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (tooLarge) {
+        reject(new Error("oEmbed response is too large."));
+        return;
+      }
+      reject(error instanceof Error ? error : new Error("Failed to fetch oEmbed."));
+    };
+    const succeed = (response) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(response);
+    };
+    const onResponse = (incoming) => {
+      const chunks = [];
+      let received = 0;
+      incoming.on("data", (chunk) => {
+        received += chunk.length;
+        if (received > MAX_BODY_BYTES) {
+          tooLarge = true;
+          incoming.destroy();
+          return;
+        }
+        chunks.push(chunk);
+      });
+      incoming.on("error", fail);
+      incoming.on("end", () => {
+        if (tooLarge) {
+          fail(new Error("oEmbed response is too large."));
+          return;
+        }
+        try {
+          const encoding = typeof incoming.headers["content-encoding"] === "string" ? incoming.headers["content-encoding"] : void 0;
+          const body = decodeBody(Buffer.concat(chunks), encoding);
+          succeed(new Response(body, {
+            status: incoming.statusCode ?? 502,
+            headers: responseHeaders(incoming.headers)
+          }));
+        } catch (error) {
+          fail(error);
+        }
+      });
+    };
+    const req = secure ? httpsRequest({ ...options, servername: hostname }, onResponse) : httpRequest(options, onResponse);
+    req.on("error", fail);
+    req.end();
+  });
+}