emdash 1.0.1 → 1.2.0

package/dist/index-DYsn97dY.d.mts

@@ -0,0 +1,623 @@
+import { n as ContentBylineCredit, t as BylineSummary, u as FindManyResult } from "./types-Ff85fTzU.mjs";
+import { t as Database } from "./types-UKr5Sf4y.mjs";
+import { d as ImportSource, g as ProbeResult } from "./types-Bq9Wohd7.mjs";
+import { Kysely } from "kysely";
+import { slugify } from "@emdash-cms/admin/slugify";
+import { PortableTextBlock } from "@emdash-cms/gutenberg-to-portable-text";
+import { Readable } from "node:stream";
+
+//#region src/database/repositories/byline.d.ts
+interface CreateBylineInput {
+  slug: string;
+  displayName: string;
+  bio?: string | null;
+  avatarMediaId?: string | null;
+  websiteUrl?: string | null;
+  userId?: string | null;
+  isGuest?: boolean;
+  /**
+   * Locale this byline row belongs to. When omitted, the DB DEFAULT (the
+   * configured `defaultLocale` after migration 040) is used. Keeps behaviour
+   * consistent with `TaxonomyRepository.create`.
+   */
+  locale?: string;
+  /**
+   * When set, the new row joins the source byline's translation_group rather
+   * than minting a fresh one. The source must exist; otherwise the create
+   * throws. Mirrors `TaxonomyRepository.create`.
+   */
+  translationOf?: string;
+  /**
+   * Byline custom-field values to seed on the new row (Phase 6 of
+   * Discussion #1174). Same semantics as `UpdateBylineInput.customFields`:
+   * keys must match registered slugs in `_emdash_byline_fields`, values
+   * are validated against the field's type, and writes route to
+   * `_emdash_byline_field_values` (translatable) or
+   * `_emdash_byline_field_group_values` (group-shared). Validation runs
+   * before the row insert so a bad value can't leave a bare byline behind.
+   */
+  customFields?: Record<string, unknown>;
+}
+interface UpdateBylineInput {
+  slug?: string;
+  displayName?: string;
+  bio?: string | null;
+  avatarMediaId?: string | null;
+  websiteUrl?: string | null;
+  userId?: string | null;
+  isGuest?: boolean;
+  /**
+   * Byline custom-field values to write (Phase 3 of Discussion #1174).
+   *
+   * Each key must match a registered slug in `_emdash_byline_fields`;
+   * unknown keys throw `EmDashValidationError`. Per-field writes route
+   * to `_emdash_byline_field_values` (when the field's `translatable`
+   * flag is true) or `_emdash_byline_field_group_values` (when false).
+   * A value of `null` clears the row.
+   *
+   * Values are validated against the field's type:
+   * - `string` / `text` / `url` accept a `string`
+   * - `boolean` accepts a `boolean`
+   * - `select` accepts a `string` that appears in `validation.options`
+   *
+   * Writes are idempotent (`INSERT … ON CONFLICT DO UPDATE`), so
+   * retrying the same update produces the same DB state.
+   */
+  customFields?: Record<string, unknown>;
+}
+interface ContentBylineInput {
+  bylineId: string;
+  roleLabel?: string | null;
+}
+/**
+ * Byline repository for content credits.
+ *
+ * Bylines are per-locale (migration 040). Translations of the same byline
+ * share a `translation_group` ULID. `_emdash_content_bylines.byline_id` and
+ * `ec_*.primary_byline_id` store the translation_group (not a row id) so a
+ * single credit spans every locale variant of a byline.
+ *
+ * The repository does not resolve locale fallbacks on its own — callers
+ * supply the locale they want. Hydration is strict per locale: a credit at
+ * locale X renders iff a byline row exists at locale X within the credited
+ * translation group. This mirrors `TaxonomyRepository.getTermsForEntry` and
+ * the convention established by PR #916.
+ *
+ * Runtime helpers in `packages/core/src/bylines/index.ts` may layer fallback
+ * resolution on top for the "look up one byline by slug" path, but the
+ * relation-hydration methods on this class are always strict.
+ */
+declare class BylineRepository {
+  private db;
+  constructor(db: Kysely<Database>);
+  /**
+   * Merge `customFields` onto each `BylineSummary` produced from the
+   * given rows. Two batched queries total — one against
+   * `_emdash_byline_field_values` (keyed by `byline_id`), one against
+   * `_emdash_byline_field_group_values` (keyed by `translation_group`)
+   * — both chunked at `SQL_BATCH_SIZE` for D1's bound-parameter cap.
+   *
+   * When zero fields are registered, every row gets `customFields = {}`
+   * with no value-table reads (the field-defs cache returns `[]`).
+   * Group-shared values are looked up via the row's `translation_group`,
+   * so every locale sibling of the same byline identity sees the same
+   * non-translatable value without re-reading per row.
+   *
+   * **Duplicate-row handling.** Callers (notably `getContentBylinesMany`
+   * for list views with repeated authors) can pass the same byline row
+   * multiple times. We assign values by *iterating both `rows` and
+   * `summaries` in lockstep by index*, not by deduping into a Map keyed
+   * on byline id. A Map approach silently drops earlier duplicates' merge
+   * step (last writer wins, earlier instances keep their initial `{}`).
+   * Iterating by index gives every duplicate its own merged copy.
+   *
+   * Hydration is *strict per row* — values are merged onto whichever
+   * `BylineRow` produced them. Fallback semantics (e.g. "if no value
+   * for this locale, show the default-locale value") are not the
+   * repository's concern; consumers layer them on top if wanted, the
+   * same way `BylineRepository` doesn't resolve locale fallback for
+   * the base byline lookup.
+   */
+  private withCustomFields;
+  private withCustomFieldsOne;
+  /**
+   * Hydrate `customFields` on each `BylineSummary`, mutating in place.
+   *
+   * The public entry point for callers that fetch byline rows in
+   * multiple passes (e.g. `getBylinesForEntries`, which buckets by
+   * locale and calls `getContentBylinesMany` per bucket) and want a
+   * single batched hydration over the union of bylines, not one per
+   * pass. Use with the `skipHydration` option on the read methods to
+   * defer customFields work to a single call here.
+   *
+   * Two batched queries total (translatable + group-shared) regardless
+   * of how many bylines, locales, or translation_groups are in the
+   * input — meets the Phase 3 query-count envelope for mixed-locale
+   * list views even when sibling locales reference disjoint
+   * translation_groups.
+   *
+   * Replaces any existing `customFields` on each summary with a freshly
+   * fetched map. Callers that want to merge rather than replace should
+   * not use this entry point.
+   */
+  hydrateBylineCustomFields(summaries: BylineSummary[]): Promise<void>;
+  /**
+   * Shared merge engine for `withCustomFields` and
+   * `hydrateBylineCustomFields`. Reads field defs (cached), batches the
+   * translatable + group-shared fetches, and walks `summaries` directly
+   * to apply values.
+   *
+   * Iterates `summaries` (not a `summaryById` map) so duplicate
+   * `BylineSummary` objects sharing the same `id` — e.g. the same
+   * author credited to multiple entries — each get their own merged
+   * values. The previous Map-based dedup silently dropped earlier
+   * duplicates' merge step.
+   */
+  private applyCustomFieldsTo;
+  /**
+   * Resolve the group-shared custom-field values for a set of
+   * translation_groups, sharing work across hydration calls within the
+   * same request via per-group `requestCached` entries.
+   *
+   * The non-translatable storage table (`_emdash_byline_field_group_values`)
+   * is keyed by `translation_group`, which is locale-agnostic. Combining
+   * this method with `skipHydration` on `getContentBylinesMany` and a
+   * single `hydrateBylineCustomFields` call (see
+   * `getBylinesForEntries`) keeps mixed-locale list hydration to **one**
+   * batched group-shared SQL per request — even with disjoint
+   * translation_groups across locale buckets. Solo callers (`findById`,
+   * `findMany`, etc.) still get the same per-call batching they had
+   * before; the cache simply means a second call in the same request
+   * for an overlapping group is free.
+   *
+   * Cache key: `byline-field-group-values:${groupId}` — one entry per
+   * group. Writes use `setRequestCacheEntry` (idempotent, doesn't
+   * overwrite); `BylineRepository.update` calls `clearRequestCacheEntry`
+   * after a group-shared write to keep the cache fresh within the same
+   * request.
+   */
+  private loadGroupValuesByIds;
+  /**
+   * Every byline column plus the avatar's media columns, folded in by the
+   * same `LEFT JOIN media` the credit-hydration queries use. Only the
+   * single-row finders select this; `findMany` stays a single-table scan.
+   */
+  private selectBylineWithAvatar;
+  findById(id: string): Promise<BylineSummary | null>;
+  /**
+   * Find a byline by slug. When `locale` is provided, filter by it strictly.
+   * When omitted, returns the lowest-locale-code match (deterministic across
+   * calls). Mirrors `TaxonomyRepository.findBySlug`.
+   */
+  findBySlug(slug: string, options?: {
+    locale?: string;
+  }): Promise<BylineSummary | null>;
+  /**
+   * Find the byline linked to a CMS user. Post-migration 040 the partial
+   * unique on user_id is `(user_id, locale)`, so `locale` is required to
+   * disambiguate when multiple locale variants exist. When omitted, returns
+   * the lowest-locale-code match.
+   */
+  findByUserId(userId: string, options?: {
+    locale?: string;
+  }): Promise<BylineSummary | null>;
+  findMany(options?: {
+    search?: string;
+    isGuest?: boolean;
+    userId?: string;
+    locale?: string;
+    cursor?: string;
+    limit?: number;
+  }): Promise<FindManyResult<BylineSummary>>;
+  /**
+   * List every sibling row in `translation_group`. Used by the admin
+   * `TranslationsPanel` to render one entry per configured locale.
+   */
+  listTranslations(id: string): Promise<BylineSummary[]>;
+  /**
+   * Direct lookup by `translation_group`. Returns every locale variant of a
+   * byline, ordered by locale code (deterministic).
+   */
+  findByTranslationGroup(translationGroup: string): Promise<BylineSummary[]>;
+  /**
+   * Validate a `customFields` input map into a write list before any row
+   * write — throws `EmDashValidationError` on unknown slugs, type
+   * mismatches, or select-choice misses.
+   */
+  private resolveCustomFieldWrites;
+  /**
+   * Write a validated custom-field list against a byline row inside the
+   * caller's transaction. Per-field writes route to
+   * `_emdash_byline_field_values` (translatable) or
+   * `_emdash_byline_field_group_values` (group-shared); `null` clears.
+   * Returns `true` when any group-shared row was touched so the caller
+   * can invalidate the per-request cache post-commit.
+   */
+  private applyCustomFieldWritesInTrx;
+  create(input: CreateBylineInput): Promise<BylineSummary>;
+  update(id: string, input: UpdateBylineInput): Promise<BylineSummary | null>;
+  /**
+   * Delete a byline row. When this row is the last sibling in its
+   * translation group, also drops every junction row pointing at the group,
+   * clears `primary_byline_id` references, and removes the byline's
+   * non-translatable custom-field values. When other siblings remain in
+   * the group, junctions, `primary_byline_id` pointers, and group-shared
+   * custom-field values stay intact — the credit (and its shared metadata)
+   * lives on at other locales.
+   *
+   * **Application-level cascade.** The byline domain has standardised on
+   * app-level cascade rather than trusting FK ON DELETE CASCADE, partly
+   * because migration 040 had to strip its own FK to support the
+   * translation_group remap (#1021), and partly so cleanup doesn't
+   * depend on `PRAGMA foreign_keys = ON` (set in production via
+   * `connection.ts:60`, but easy to bypass in tests, scripts, and
+   * one-off tools). Every byline-related deletion table is cleared
+   * explicitly here:
+   *
+   * - `_emdash_byline_field_values` (per-byline translatable values) —
+   *   migration 041 declares FK ON DELETE CASCADE on `byline_id`; the
+   *   explicit DELETE removes the dependency on that pragma.
+   * - `_emdash_content_bylines` — migration 040 dropped its FK.
+   * - `ec_*.primary_byline_id` — never had an FK.
+   * - `_emdash_byline_field_group_values` (translation-group-keyed) —
+   *   keyed by a text column with no FK to bylines, so app-level cleanup
+   *   is the only path.
+   *
+   * The FKs that remain (migration 041) serve as defense-in-depth.
+   */
+  delete(id: string): Promise<boolean>;
+  /**
+   * Strict per-locale credit hydration. Joins `_emdash_content_bylines` to
+   * `_emdash_bylines` on `translation_group = byline_id`, then filters to
+   * the requested locale. Credits whose translation group lacks a row at
+   * the requested locale are omitted — callers wanting fallback behaviour
+   * apply it themselves. Mirrors `TaxonomyRepository.getTermsForEntry`.
+   */
+  getContentBylines(collectionSlug: string, contentId: string, options?: {
+    locale?: string;
+  }): Promise<ContentBylineCredit[]>;
+  /**
+   * Does this entry have any explicit byline credits — at any locale?
+   *
+   * Used to disambiguate "no credits exist" (fall back to author-linked
+   * byline) from "credits exist but don't resolve at the requested locale"
+   * (strict per-locale model: render no byline). Without this check the
+   * locale-strict hydration would silently turn a missing translation into
+   * an author-inferred byline, contradicting editorial intent.
+   */
+  hasContentBylines(collectionSlug: string, contentId: string): Promise<boolean>;
+  /**
+   * Batch variant of `hasContentBylines`. Returns the set of content IDs
+   * that have at least one junction row (locale-agnostic).
+   */
+  hasContentBylinesMany(collectionSlug: string, contentIds: string[]): Promise<Set<string>>;
+  /**
+   * Batch variant of `getContentBylines`. Same strict-per-locale semantics
+   * applied to the requested locale (single value, not per-entry).
+   *
+   * When callers need per-entry-locale filtering (e.g. a list endpoint
+   * returning entries at mixed locales), they should group the input ids by
+   * the entry's locale and call this method once per group.
+   *
+   * When the caller will issue multiple `getContentBylinesMany` calls in
+   * one request (e.g. per locale bucket) and wants a *single* batched
+   * customFields hydration over the union of returned bylines, pass
+   * `skipHydration: true` on each call and finish with
+   * `hydrateBylineCustomFields(allBylines)`. The returned bylines carry
+   * `customFields = {}` until that hydration call runs — matching the
+   * "always populated" invariant from AC #6 — so callers that forget to
+   * hydrate get an empty map rather than `undefined`.
+   */
+  getContentBylinesMany(collectionSlug: string, contentIds: string[], options?: {
+    locale?: string;
+    skipHydration?: boolean;
+  }): Promise<Map<string, ContentBylineCredit[]>>;
+  /**
+   * Batch-fetch byline profiles linked to user IDs in a single query.
+   * Strict-locale variant of `findByUserId`.
+   *
+   * `skipHydration: true` returns bylines with `customFields = {}` so
+   * callers issuing multiple `findByUserIds` calls in one request (e.g.
+   * the per-locale-bucket author-fallback path in `getBylinesForEntries`)
+   * can defer customFields hydration to a single batched
+   * `hydrateBylineCustomFields` call across the union — keeping the
+   * Phase 3 query-count envelope at "+1 group-shared query per
+   * hydration pass" even when buckets fetch disjoint author bylines.
+   */
+  findByUserIds(userIds: string[], options?: {
+    locale?: string;
+    skipHydration?: boolean;
+  }): Promise<Map<string, BylineSummary>>;
+  /**
+   * Clone every junction row from `sourceContentId` to `targetContentId`,
+   * preserving `sort_order` and `role_label`. Used by the content
+   * translation flow: a newly created translation inherits the source's
+   * byline credits at the storage level. Because the junction stores
+   * `translation_group` (not a row id), the copy is locale-agnostic — the
+   * credits resolve to whichever locale variants of each byline exist when
+   * the translated entry is hydrated.
+   *
+   * No-op when the source has no credits. Skips when the target already
+   * has credits (idempotent for re-runs).
+   */
+  copyContentBylines(collection: string, sourceContentId: string, targetContentId: string): Promise<void>;
+  /**
+   * Replace the set of byline credits on a content entry. Accepts row ids
+   * at the wire (consistent with how the admin sends them), translates
+   * each to its `translation_group` on write, and stores the group in
+   * `_emdash_content_bylines.byline_id` and `ec_*.primary_byline_id`.
+   *
+   * The returned credits are hydrated with strict-locale matching at the
+   * locale of the rows the caller supplied (i.e. the locale of the byline
+   * each `bylineId` resolves to) — adequate for the autosave round-trip,
+   * which then re-hydrates the entry against its own locale separately.
+   */
+  setContentBylines(collectionSlug: string, contentId: string, inputBylines: ContentBylineInput[]): Promise<ContentBylineCredit[]>;
+  deleteContentBylines(collectionSlug: string, contentId: string): Promise<number>;
+}
+//#endregion
+//#region src/utils/slugify.d.ts
+/**
+ * Decode a URI-encoded slug parameter.
+ *
+ * Browsers percent-encode non-ASCII characters in URLs, so a slug like
+ * "మేష-రాసి" arrives as "%e0%b0%ae%e0%b1%87%e0%b0%b7-%e0%b0%b0%e0%b0%be%e0%b0%b8%e0%b0%bf".
+ * Call this on `Astro.params.slug` before using it in database lookups.
+ */
+declare function decodeSlug(raw: string | undefined): string | undefined;
+//#endregion
+//#region src/cli/wxr/parser.d.ts
+/**
+ * Parsed WordPress export data
+ */
+interface WxrData {
+  /** Site metadata */
+  site: WxrSite;
+  /** Posts (including custom post types) */
+  posts: WxrPost[];
+  /** Media attachments */
+  attachments: WxrAttachment[];
+  /** Categories */
+  categories: WxrCategory[];
+  /** Tags */
+  tags: WxrTag[];
+  /** Authors */
+  authors: WxrAuthor[];
+  /** All taxonomy terms (including custom taxonomies and nav_menu) */
+  terms: WxrTerm[];
+  /** Parsed navigation menus */
+  navMenus: WxrNavMenu[];
+}
+interface WxrSite {
+  title?: string;
+  link?: string;
+  description?: string;
+  language?: string;
+  baseSiteUrl?: string;
+  baseBlogUrl?: string;
+}
+interface WxrPost {
+  id?: number;
+  title?: string;
+  link?: string;
+  pubDate?: string;
+  creator?: string;
+  guid?: string;
+  description?: string;
+  content?: string;
+  excerpt?: string;
+  postDate?: string;
+  postDateGmt?: string;
+  postModified?: string;
+  postModifiedGmt?: string;
+  commentStatus?: string;
+  pingStatus?: string;
+  status?: string;
+  postType?: string;
+  postName?: string;
+  postPassword?: string;
+  isSticky?: boolean;
+  /** Parent post ID for hierarchical content (pages) */
+  postParent?: number;
+  /** Menu order for sorting */
+  menuOrder?: number;
+  categories: string[];
+  tags: string[];
+  /** Custom taxonomy assignments beyond categories/tags */
+  customTaxonomies?: Map<string, string[]>;
+  /**
+   * Display labels for per-item category/tag/custom-taxonomy assignments,
+   * captured from `<category domain="..." nicename="...">Label</category>`
+   * text content. Used by the importer to back-fill term labels when a
+   * `<wp:category>` or `<wp:tag>` block wasn't present at the top of the
+   * WXR (older / hand-edited exports). Keyed by
+   * `${normalisedTaxonomy}\u0000${slug}` so categories and tags don't
+   * collide.
+   */
+  taxonomyLabels?: Map<string, string>;
+  meta: Map<string, string>;
+  /**
+   * BCP 47 locale code extracted from a detected multilingual plugin
+   * (WPML's `_icl_lang_code` or Polylang's per-post language taxonomy).
+   * Absent when no per-post locale could be determined.
+   */
+  locale?: string;
+  /**
+   * Source-side translation group ID extracted from a detected multilingual
+   * plugin (WPML's `trid` / `_icl_translation_id`, or a synthesized id derived
+   * from Polylang's `_translations` meta). Posts sharing a `translationGroup`
+   * are translations of one another. The string is opaque -- consumers use it
+   * only as a key to link posts.
+   */
+  translationGroup?: string;
+}
+interface WxrAttachment {
+  id?: number;
+  title?: string;
+  url?: string;
+  postDate?: string;
+  meta: Map<string, string>;
+}
+interface WxrCategory {
+  id?: number;
+  nicename?: string;
+  name?: string;
+  parent?: string;
+  description?: string;
+}
+interface WxrTag {
+  id?: number;
+  slug?: string;
+  name?: string;
+  description?: string;
+}
+/**
+ * Generic taxonomy term (categories, tags, nav_menu, custom taxonomies)
+ */
+interface WxrTerm {
+  id: number;
+  taxonomy: string;
+  slug: string;
+  name: string;
+  parent?: string;
+  description?: string;
+}
+/**
+ * Navigation menu structure
+ */
+interface WxrNavMenu {
+  id: number;
+  name: string;
+  label: string;
+  items: WxrNavMenuItem[];
+}
+/**
+ * Navigation menu item
+ */
+interface WxrNavMenuItem {
+  id: number;
+  menuId: number;
+  parentId?: number;
+  sortOrder: number;
+  type: "custom" | "post_type" | "taxonomy";
+  objectType?: string;
+  objectId?: number;
+  url?: string;
+  title: string;
+  target?: string;
+  classes?: string;
+}
+interface WxrAuthor {
+  id?: number;
+  login?: string;
+  email?: string;
+  displayName?: string;
+  firstName?: string;
+  lastName?: string;
+}
+/**
+ * Parse a WordPress WXR export file
+ */
+declare function parseWxr(stream: Readable): Promise<WxrData>;
+/**
+ * Parse a WordPress WXR export from a string
+ *
+ * Uses the non-streaming SAX parser API for compatibility with
+ * environments that don't have Node.js streams (e.g., Cloudflare Workers).
+ */
+declare function parseWxrString(xml: string): Promise<WxrData>;
+//#endregion
+//#region src/import/sections.d.ts
+/**
+ * Result of sections import operation
+ */
+interface SectionsImportResult {
+  /** Number of sections created */
+  sectionsCreated: number;
+  /** Number of sections skipped (already exist) */
+  sectionsSkipped: number;
+  /** Errors encountered during import */
+  errors: Array<{
+    title: string;
+    error: string;
+  }>;
+}
+/**
+ * Import reusable blocks (wp_block post type) from WXR as sections
+ *
+ * @param posts - All posts from WXR (will filter to wp_block)
+ * @param db - Database connection
+ * @returns Import result with counts
+ */
+declare function importReusableBlocksAsSections(posts: WxrPost[], db: Kysely<Database>): Promise<SectionsImportResult>;
+//#endregion
+//#region src/import/registry.d.ts
+/**
+ * Register an import source
+ */
+declare function registerSource(source: ImportSource): void;
+/**
+ * Get a source by ID
+ */
+declare function getSource(id: string): ImportSource | undefined;
+/**
+ * Get all registered sources
+ */
+declare function getAllSources(): ImportSource[];
+/**
+ * Get sources that can handle file uploads
+ */
+declare function getFileSources(): ImportSource[];
+/**
+ * Get sources that can probe URLs
+ */
+declare function getUrlSources(): ImportSource[];
+/**
+ * Probe a URL against all registered sources
+ *
+ * Returns probe results sorted by confidence (definite > likely > possible)
+ */
+declare function probeUrl(url: string): Promise<ProbeResult>;
+/**
+ * Clear all registered sources (useful for testing)
+ */
+declare function clearSources(): void;
+//#endregion
+//#region src/import/sources/wxr.d.ts
+declare const wxrSource: ImportSource;
+/**
+ * Parse a WXR date with the correct fallback chain:
+ * 1. GMT date (always UTC, most reliable)
+ * 2. pubDate (RFC 2822, includes timezone offset)
+ * 3. Site-local date (MySQL datetime without timezone, imprecise but best available)
+ *
+ * Returns undefined when none of the inputs yield a valid date.
+ * Callers that need a guaranteed Date should use `?? new Date()`.
+ */
+declare function parseWxrDate(gmtDate: string | undefined, pubDate: string | undefined, localDate: string | undefined): Date | undefined;
+//#endregion
+//#region src/import/sources/wordpress-rest.d.ts
+declare const wordpressRestSource: ImportSource;
+//#endregion
+//#region src/import/sources/wordpress-plugin.d.ts
+/**
+ * Fetch taxonomies from plugin API
+ */
+declare function fetchPluginTaxonomies(siteUrl: string, authToken: string): Promise<Array<{
+  name: string;
+  label: string; /** Singular label (added in emdash-exporter 1.2.0) */
+  label_singular?: string;
+  hierarchical: boolean; /** WP post types this taxonomy is registered for (added in emdash-exporter 1.2.0) */
+  post_types?: string[];
+  terms: Array<{
+    id: number;
+    name: string;
+    slug: string;
+    description: string;
+    parent: number | null;
+    count: number;
+  }>;
+}>>;
+//#endregion
+export { decodeSlug as C, ContentBylineInput as E, parseWxrString as S, BylineRepository as T, WxrPost as _, clearSources as a, WxrTerm as b, getSource as c, registerSource as d, importReusableBlocksAsSections as f, WxrData as g, WxrCategory as h, wxrSource as i, getUrlSources as l, WxrAuthor as m, wordpressRestSource as n, getAllSources as o, WxrAttachment as p, parseWxrDate as r, getFileSources as s, fetchPluginTaxonomies as t, probeUrl as u, WxrSite as v, slugify as w, parseWxr as x, WxrTag as y };
+//# sourceMappingURL=index-DYsn97dY.d.mts.map

package/dist/index-DYsn97dY.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DYsn97dY.d.mts","names":[],"sources":["../src/database/repositories/byline.ts","../src/utils/slugify.ts","../src/cli/wxr/parser.ts","../src/import/sections.ts","../src/import/registry.ts","../src/import/sources/wxr.ts","../src/import/sources/wordpress-rest.ts","../src/import/sources/wordpress-plugin.ts"],"mappings":"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"}