@artinstack/migrator 0.1.0 → 0.1.2

package/dist/chunk-FXXKLYO5.js

@@ -1,1076 +0,0 @@
-import {
-  SquarespaceCollectionClient,
-  discoverContentAssetUrls,
-  enumerateSquarespaceEntities,
-  linkToPath,
-  sanitizeSlug,
-  summarizeSquarespaceExport,
-  validateSquarespaceExportFile
-} from "./chunk-LKNIQQJO.js";
-
-// src/parsers/wordpress/parse-wxr.ts
-import { readFile } from "fs/promises";
-import { basename } from "path";
-import { XMLParser } from "fast-xml-parser";
-var PLATFORM = "wordpress";
-function asArray(value) {
-  if (value === void 0) return [];
-  return Array.isArray(value) ? value : [value];
-}
-function textValue(value) {
-  if (value === void 0 || value === null) return "";
-  if (typeof value === "string" || typeof value === "number") return String(value);
-  if (typeof value === "object" && value !== null && "#text" in value) {
-    return String(value["#text"] ?? "");
-  }
-  return String(value);
-}
-function mapPublishStatus(wpStatus) {
-  switch ((wpStatus ?? "").toLowerCase()) {
-    case "publish":
-      return "published";
-    case "draft":
-    case "pending":
-      return "draft";
-    default:
-      return "archived";
-  }
-}
-function getContentEncoded(item) {
-  const content = item.content;
-  if (content !== void 0) {
-    if (typeof content === "string") return content;
-    return textValue(content.encoded);
-  }
-  return textValue(item.encoded);
-}
-function sourceMeta(id, link, exportedAt) {
-  return {
-    platform: PLATFORM,
-    id,
-    url: link || void 0,
-    path: linkToPath(link),
-    exportedAt
-  };
-}
-function getExcerpt(item) {
-  const excerpt = item.excerpt;
-  if (!excerpt) return "";
-  if (typeof excerpt === "string") return excerpt;
-  return textValue(excerpt.encoded);
-}
-function getPostMeta(item, key) {
-  for (const meta of asArray(item.postmeta)) {
-    if (textValue(meta.meta_key) === key) {
-      return textValue(meta.meta_value);
-    }
-  }
-  return void 0;
-}
-function parseItems(xml) {
-  const parser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    removeNSPrefix: true,
-    trimValues: false,
-    parseTagValue: false
-  });
-  const doc = parser.parse(xml);
-  return asArray(doc.rss?.channel?.item);
-}
-function buildAttachmentIndex(items) {
-  const index = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    if (textValue(item.post_type) !== "attachment") continue;
-    const id = textValue(item.post_id);
-    const url = textValue(item.attachment_url) || textValue(item.link);
-    if (!id || !url) continue;
-    const filename = basename(new URL(url, "http://local.invalid").pathname) || `attachment-${id}`;
-    index.set(id, {
-      sourceUrl: url,
-      filename,
-      mimeType: getPostMeta(item, "_wp_attached_file") ? void 0 : guessMime(filename),
-      title: textValue(item.title)
-    });
-  }
-  return index;
-}
-function guessMime(filename) {
-  const ext = filename.split(".").pop()?.toLowerCase();
-  const map = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    pdf: "application/pdf"
-  };
-  return ext ? map[ext] : void 0;
-}
-function collectTaxonomies(items) {
-  const categories = /* @__PURE__ */ new Map();
-  const tags = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const postType = textValue(item.post_type);
-    if (postType !== "post" && postType !== "page") continue;
-    for (const cat of asArray(item.category)) {
-      const domain = cat["@_domain"] ?? "";
-      const nicename = sanitizeSlug(cat["@_nicename"] ?? textValue(cat["#text"]));
-      const name = textValue(cat["#text"]) || nicename;
-      if (!nicename) continue;
-      if (domain === "category") {
-        if (!categories.has(nicename)) {
-          categories.set(nicename, {
-            type: "category",
-            source: sourceMeta(`cat:${nicename}`),
-            sourceId: `cat:${nicename}`,
-            name,
-            slug: nicename
-          });
-        }
-      } else if (domain === "post_tag") {
-        if (!tags.has(nicename)) {
-          tags.set(nicename, {
-            type: "tag",
-            source: sourceMeta(`tag:${nicename}`),
-            sourceId: `tag:${nicename}`,
-            name,
-            slug: nicename
-          });
-        }
-      }
-    }
-  }
-  return { categories, tags };
-}
-function collectInlineAssets(html, attachmentIndex, seenUrls, exportedAt) {
-  const assets = [];
-  for (const src of discoverContentAssetUrls(html)) {
-    if (seenUrls.has(src)) continue;
-    seenUrls.add(src);
-    let filename;
-    try {
-      filename = basename(new URL(src, "http://local.invalid").pathname) || "inline-asset";
-    } catch {
-      filename = "inline-asset";
-    }
-    assets.push({
-      type: "asset",
-      source: sourceMeta(`url:${src}`, src, exportedAt),
-      sourceId: `url:${src}`,
-      sourceUrl: src,
-      filename,
-      mimeType: guessMime(filename)
-    });
-  }
-  for (const [id, entry] of attachmentIndex) {
-    if (seenUrls.has(entry.sourceUrl)) continue;
-    void id;
-  }
-  return assets;
-}
-async function* enumerateWxrEntities(options) {
-  const xml = await readFile(options.filePath, "utf8");
-  const items = parseItems(xml);
-  const attachmentIndex = buildAttachmentIndex(items);
-  const { categories, tags } = collectTaxonomies(items);
-  const seenAssetUrls = /* @__PURE__ */ new Set();
-  const emittedAttachmentIds = /* @__PURE__ */ new Set();
-  for (const category of categories.values()) {
-    yield category;
-  }
-  for (const tag of tags.values()) {
-    yield tag;
-  }
-  for (const [id, entry] of attachmentIndex) {
-    emittedAttachmentIds.add(id);
-    seenAssetUrls.add(entry.sourceUrl);
-    yield {
-      type: "asset",
-      source: sourceMeta(id, entry.sourceUrl, options.exportedAt),
-      sourceId: id,
-      sourceUrl: entry.sourceUrl,
-      filename: entry.filename,
-      mimeType: entry.mimeType,
-      caption: entry.title
-    };
-  }
-  for (const item of items) {
-    const postType = textValue(item.post_type);
-    if (postType !== "post" && postType !== "page") continue;
-    const id = textValue(item.post_id);
-    const link = textValue(item.link);
-    const slug = sanitizeSlug(textValue(item.post_name) || textValue(item.title) || id);
-    const rawHtml = getContentEncoded(item);
-    for (const asset of collectInlineAssets(
-      rawHtml,
-      attachmentIndex,
-      seenAssetUrls,
-      options.exportedAt
-    )) {
-      yield asset;
-    }
-    const categorySlugs = [];
-    const tagSlugs = [];
-    for (const cat of asArray(item.category)) {
-      const domain = cat["@_domain"] ?? "";
-      const nicename = sanitizeSlug(cat["@_nicename"] ?? textValue(cat["#text"]));
-      if (!nicename) continue;
-      if (domain === "category") categorySlugs.push(nicename);
-      if (domain === "post_tag") tagSlugs.push(nicename);
-    }
-    if (postType === "post") {
-      const thumbnailId = getPostMeta(item, "_thumbnail_id");
-      let featuredAssetSourceId;
-      if (thumbnailId && attachmentIndex.has(thumbnailId)) {
-        featuredAssetSourceId = thumbnailId;
-      }
-      const post = {
-        type: "post",
-        source: sourceMeta(id, link, options.exportedAt),
-        sourceId: id,
-        title: textValue(item.title) || slug,
-        slug,
-        excerpt: getExcerpt(item) || void 0,
-        contentHtml: rawHtml,
-        publishedAt: textValue(item.post_date) || void 0,
-        status: mapPublishStatus(textValue(item.status)),
-        categorySlugs: categorySlugs.length ? categorySlugs : void 0,
-        tagSlugs: tagSlugs.length ? tagSlugs : void 0,
-        sourceFeaturedMediaId: thumbnailId,
-        featuredAssetSourceId
-      };
-      yield post;
-    } else {
-      const isHomePage = getPostMeta(item, "_wp_show_on_front") === "1" || getPostMeta(item, "page_on_front") === "1";
-      const page = {
-        type: "page",
-        source: sourceMeta(id, link, options.exportedAt),
-        sourceId: id,
-        title: textValue(item.title) || slug,
-        slug,
-        contentHtml: rawHtml,
-        isHomePage: isHomePage || void 0,
-        status: mapPublishStatus(textValue(item.status))
-      };
-      yield page;
-    }
-  }
-}
-async function validateWxrFile(filePath) {
-  const issues = [];
-  let xml;
-  try {
-    xml = await readFile(filePath, "utf8");
-  } catch {
-    return {
-      ok: false,
-      issues: [{ code: "file_not_found", message: `Cannot read file: ${filePath}` }],
-      summary: {}
-    };
-  }
-  const looksLikeWxr = xml.includes("<rss") && (xml.includes("wp:wxr_version") || xml.includes("xmlns:wp=") || xml.includes("WordPress eXtended RSS"));
-  if (!looksLikeWxr) {
-    issues.push({ code: "invalid_wxr", message: "File does not appear to be WordPress WXR" });
-  }
-  const items = parseItems(xml);
-  const summary = {
-    posts: items.filter((i) => textValue(i.post_type) === "post").length,
-    pages: items.filter((i) => textValue(i.post_type) === "page").length,
-    assets: items.filter((i) => textValue(i.post_type) === "attachment").length,
-    portfolios: 0,
-    categories: 0,
-    tags: 0
-  };
-  const { categories, tags } = collectTaxonomies(items);
-  summary.categories = categories.size;
-  summary.tags = tags.size;
-  return { ok: issues.length === 0, issues, summary };
-}
-
-// src/parsers/wordpress/index.ts
-function resolvePath(input) {
-  if (typeof input === "string") return input;
-  if (input && typeof input === "object" && "path" in input) {
-    return String(input.path);
-  }
-  throw new Error("WordPress adapter requires input path (string or { path })");
-}
-var wordpressAdapter = {
-  platform: "wordpress",
-  async validateInput(input) {
-    const path = resolvePath(input);
-    const result = await validateWxrFile(path);
-    return {
-      ok: result.ok,
-      issues: result.issues,
-      summary: result.summary
-    };
-  },
-  enumerateEntities(ctx) {
-    const path = resolvePath(ctx.input);
-    return enumerateWxrEntities({ filePath: path });
-  }
-};
-
-// src/parsers/smugmug/api.ts
-import { createHmac, randomBytes } from "crypto";
-import { z } from "zod";
-var SMUGMUG_API_HOST = "api.smugmug.com";
-var SMUGMUG_API_BASE = `https://${SMUGMUG_API_HOST}/api/v2`;
-var SMUGMUG_OAUTH_ENDPOINTS = {
-  requestToken: "https://api.smugmug.com/services/oauth/1.0a/getRequestToken",
-  authorize: "https://api.smugmug.com/services/oauth/1.0a/authorize",
-  accessToken: "https://api.smugmug.com/services/oauth/1.0a/getAccessToken"
-};
-var smugMugCredentialsSchema = z.object({
-  consumerKey: z.string().min(1),
-  consumerSecret: z.string().min(1),
-  accessToken: z.string().min(1),
-  accessTokenSecret: z.string().min(1)
-});
-var smugMugClientOptionsSchema = z.object({
-  credentials: smugMugCredentialsSchema,
-  pageSize: z.number().int().min(1).max(500).default(100),
-  maxRetries: z.number().int().min(0).max(10).default(3),
-  retryBaseDelayMs: z.number().int().min(0).default(500),
-  maxRetryDelayMs: z.number().int().min(0).default(8e3),
-  requestIntervalMs: z.number().int().min(0).default(200),
-  fetchImpl: z.custom().optional()
-});
-var ALBUM_IMAGES_CONFIG = {
-  expand: {
-    AlbumImage: {
-      expand: {
-        Image: {
-          filter: ["FileName", "Caption", "KeywordsArray"],
-          filteruri: ["ImageMetadata", "ImageSizeDetails"],
-          expand: {
-            ImageMetadata: {
-              filter: ["ISO", "Aperture", "ApertureValue", "ShutterSpeed", "ExposureTime", "FocalLength"]
-            },
-            ImageSizeDetails: {
-              filter: ["OriginalImageUrl"]
-            }
-          }
-        }
-      }
-    }
-  }
-};
-function oauthPercentEncode(value) {
-  return encodeURIComponent(value).replace(
-    /[!'()*]/g,
-    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
-  );
-}
-function normalizeRequestUrl(url) {
-  const protocol = url.protocol.replace(/:$/, "").toLowerCase();
-  const host = url.hostname.toLowerCase();
-  const defaultPort = protocol === "http" ? "80" : "443";
-  const port = url.port && url.port !== defaultPort ? `:${url.port}` : "";
-  return `${protocol}://${host}${port}${url.pathname}`;
-}
-function sortedParameterString(params) {
-  return Object.keys(params).sort((a, b) => a === b ? 0 : a < b ? -1 : 1).map((key) => `${oauthPercentEncode(key)}=${oauthPercentEncode(params[key])}`).join("&");
-}
-function collectSignatureParams(url, oauthParams, bodyParams) {
-  const params = { ...oauthParams };
-  url.searchParams.forEach((value, key) => {
-    params[key] = value;
-  });
-  if (bodyParams) {
-    for (const [key, value] of Object.entries(bodyParams)) {
-      params[key] = value;
-    }
-  }
-  return params;
-}
-function signSmugMugOAuthRequest(input) {
-  const url = new URL(input.url);
-  const parameterString = sortedParameterString(
-    collectSignatureParams(url, input.oauthParams, input.bodyParams)
-  );
-  const signatureBase = [
-    input.method.toUpperCase(),
-    oauthPercentEncode(normalizeRequestUrl(url)),
-    oauthPercentEncode(parameterString)
-  ].join("&");
-  const signingKey = `${oauthPercentEncode(input.credentials.consumerSecret)}&${oauthPercentEncode(input.credentials.accessTokenSecret)}`;
-  return createHmac("sha1", signingKey).update(signatureBase).digest("base64");
-}
-function buildOAuthParams(credentials, nonce, timestamp) {
-  return {
-    oauth_consumer_key: credentials.consumerKey,
-    oauth_token: credentials.accessToken,
-    oauth_signature_method: "HMAC-SHA1",
-    oauth_timestamp: timestamp,
-    oauth_nonce: nonce,
-    oauth_version: "1.0"
-  };
-}
-function buildSmugMugAuthorizationHeader(input) {
-  const nonce = input.nonce ?? randomBytes(16).toString("hex");
-  const timestamp = input.timestamp ?? String(Math.floor(Date.now() / 1e3));
-  const oauthParams = buildOAuthParams(input.credentials, nonce, timestamp);
-  const signature = signSmugMugOAuthRequest({
-    method: input.method,
-    url: input.url,
-    credentials: input.credentials,
-    oauthParams,
-    bodyParams: input.bodyParams
-  });
-  const headerParams = { ...oauthParams, oauth_signature: signature };
-  const headerValue = Object.keys(headerParams).sort().map((key) => `${oauthPercentEncode(key)}="${oauthPercentEncode(headerParams[key])}"`).join(", ");
-  return `OAuth ${headerValue}`;
-}
-function readSmugMugCredentialsFromEnv(env = process.env) {
-  return smugMugCredentialsSchema.parse({
-    consumerKey: env.SMUGMUG_CONSUMER_KEY,
-    consumerSecret: env.SMUGMUG_CONSUMER_SECRET,
-    accessToken: env.SMUGMUG_ACCESS_TOKEN,
-    accessTokenSecret: env.SMUGMUG_ACCESS_TOKEN_SECRET
-  });
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function albumKeyFromUri(uri) {
-  const match = uri.match(/\/album\/([^/?!]+)/i);
-  if (!match?.[1]) {
-    throw new Error(`Unable to parse album key from URI: ${uri}`);
-  }
-  return match[1];
-}
-function mapAlbumImage(albumImage, portfolioSourceId, sort) {
-  const image = albumImage.Image;
-  const metadata = image?.ImageMetadata ?? albumImage.ImageMetadata;
-  const originalUrl = image?.ImageSizeDetails?.OriginalImageUrl ?? albumImage.LargestImage?.Url ?? albumImage.WebUri;
-  const fileName = image?.FileName ?? albumImage.FileName;
-  return {
-    sourceId: albumImage.ImageKey,
-    portfolioSourceId,
-    sort,
-    fileName,
-    originalUrl,
-    caption: albumImage.Caption ?? image?.Caption,
-    keywords: image?.KeywordsArray?.length ? image.KeywordsArray : void 0,
-    exif: metadata ? {
-      iso: metadata.ISO,
-      aperture: metadata.Aperture ?? metadata.ApertureValue,
-      shutter: metadata.ShutterSpeed ?? metadata.ExposureTime,
-      focalLength: metadata.FocalLength
-    } : void 0
-  };
-}
-var SmugMugApiClient = class {
-  credentials;
-  pageSize;
-  maxRetries;
-  retryBaseDelayMs;
-  maxRetryDelayMs;
-  requestIntervalMs;
-  fetchImpl;
-  lastRequestAt = 0;
-  constructor(options) {
-    const parsed = smugMugClientOptionsSchema.parse(options);
-    this.credentials = parsed.credentials;
-    this.pageSize = parsed.pageSize;
-    this.maxRetries = parsed.maxRetries;
-    this.retryBaseDelayMs = parsed.retryBaseDelayMs;
-    this.maxRetryDelayMs = parsed.maxRetryDelayMs;
-    this.requestIntervalMs = parsed.requestIntervalMs;
-    this.fetchImpl = parsed.fetchImpl ?? fetch;
-  }
-  /** Validate credentials against `GET /user/!authuser`. */
-  async validateCredentials() {
-    const user = await this.getAuthUser();
-    return { nick: user.NickName, rootNodeUri: user.Uris.Node };
-  }
-  /** Crawl the authenticated user's node tree into flat export tables for `parse-node.ts`. */
-  async crawlExport() {
-    const user = await this.getAuthUser();
-    const folders = [];
-    const albums = [];
-    const images = [];
-    await this.walkNode(user.Uris.Node, void 0, folders, albums, images);
-    return {
-      exportVersion: 1,
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      Folders: folders,
-      Albums: albums,
-      Images: images
-    };
-  }
-  async getAuthUser() {
-    const envelope = await this.requestJson(`${SMUGMUG_API_BASE}/user/!authuser`);
-    return envelope.Response;
-  }
-  async walkNode(nodeUri, parentFolderId, folders, albums, images) {
-    const childrenPath = `${nodeUri}!children`;
-    for await (const child of this.paginateNodes(childrenPath)) {
-      if (child.Type === "Page") continue;
-      if (child.Type === "Folder") {
-        folders.push({
-          sourceId: child.NodeID,
-          name: child.Name,
-          parentSourceId: parentFolderId,
-          slug: child.UrlName,
-          description: child.Description
-        });
-        await this.walkNode(child.Uri, child.NodeID, folders, albums, images);
-        continue;
-      }
-      if (child.Type === "Album") {
-        albums.push({
-          sourceId: child.NodeID,
-          name: child.Name,
-          parentSourceId: parentFolderId,
-          slug: child.UrlName,
-          description: child.Description,
-          url: child.WebUri
-        });
-        const albumUri = child.Uris?.Album;
-        if (albumUri) {
-          await this.collectAlbumImages(albumUri, child.NodeID, images);
-        }
-      }
-    }
-  }
-  async collectAlbumImages(albumUri, portfolioSourceId, images) {
-    const albumKey = albumKeyFromUri(albumUri);
-    const configQuery = `_config=${encodeURIComponent(JSON.stringify(ALBUM_IMAGES_CONFIG))}`;
-    const initialPath = `${SMUGMUG_API_BASE}/album/${albumKey}!images?${configQuery}`;
-    let sort = 0;
-    for await (const albumImage of this.paginateAlbumImages(initialPath)) {
-      images.push(mapAlbumImage(albumImage, portfolioSourceId, sort));
-      sort += 1;
-    }
-  }
-  async *paginateNodes(path) {
-    for await (const page of this.paginate(path)) {
-      for (const node of page.Node ?? []) {
-        yield node;
-      }
-    }
-  }
-  async *paginateAlbumImages(path) {
-    for await (const page of this.paginate(path)) {
-      for (const albumImage of page.AlbumImage ?? []) {
-        yield albumImage;
-      }
-    }
-  }
-  async *paginate(initialPath) {
-    let nextPath = appendPagination(initialPath, this.pageSize, 1);
-    while (nextPath) {
-      const envelope = await this.requestJson(nextPath);
-      yield envelope.Response;
-      nextPath = envelope.Response.Pages?.NextPage;
-    }
-  }
-  async requestJson(pathOrUrl) {
-    const url = toAbsoluteUrl(pathOrUrl);
-    const response = await this.requestWithRetry(url);
-    const body = await response.json();
-    if (body.Code !== 200) {
-      throw new Error(`SmugMug API error ${body.Code}: ${body.Message}`);
-    }
-    return body;
-  }
-  async requestWithRetry(url) {
-    let attempt = 0;
-    while (true) {
-      await this.throttle();
-      const authorization = buildSmugMugAuthorizationHeader({
-        method: "GET",
-        url: url.toString(),
-        credentials: this.credentials
-      });
-      const response = await this.fetchImpl(url, {
-        method: "GET",
-        headers: {
-          Accept: "application/json",
-          Authorization: authorization
-        }
-      });
-      if (response.ok) {
-        return response;
-      }
-      const retryable = response.status === 429 || response.status >= 500;
-      if (!retryable || attempt >= this.maxRetries) {
-        const detail = await response.text().catch(() => "");
-        throw new Error(
-          `SmugMug HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
-        );
-      }
-      const retryAfter = Number.parseInt(response.headers.get("retry-after") ?? "", 10);
-      const delay = Number.isFinite(retryAfter) ? retryAfter * 1e3 : Math.min(this.maxRetryDelayMs, this.retryBaseDelayMs * 2 ** attempt);
-      await sleep(delay);
-      attempt += 1;
-    }
-  }
-  async throttle() {
-    if (this.requestIntervalMs <= 0) return;
-    const elapsed = Date.now() - this.lastRequestAt;
-    if (elapsed < this.requestIntervalMs) {
-      await sleep(this.requestIntervalMs - elapsed);
-    }
-    this.lastRequestAt = Date.now();
-  }
-};
-function toAbsoluteUrl(pathOrUrl) {
-  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
-    return new URL(pathOrUrl);
-  }
-  if (pathOrUrl.startsWith("/")) {
-    return new URL(`https://${SMUGMUG_API_HOST}${pathOrUrl}`);
-  }
-  return new URL(pathOrUrl);
-}
-function appendPagination(pathOrUrl, count, start) {
-  const url = toAbsoluteUrl(pathOrUrl);
-  url.searchParams.set("count", String(count));
-  url.searchParams.set("start", String(start));
-  return url.toString();
-}
-
-// src/parsers/smugmug/parse-node.ts
-import { readFile as readFile2 } from "fs/promises";
-var PLATFORM2 = "smugmug";
-var UNRESOLVED_URL_PREFIX = "unspecified://smugmug/";
-function sourceMeta2(id, url, exportedAt) {
-  return {
-    platform: PLATFORM2,
-    id,
-    url,
-    exportedAt
-  };
-}
-function guessMime2(filename) {
-  const ext = filename.split(".").pop()?.toLowerCase();
-  const map = {
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    png: "image/png",
-    gif: "image/gif",
-    webp: "image/webp",
-    tif: "image/tiff",
-    tiff: "image/tiff"
-  };
-  return ext ? map[ext] : void 0;
-}
-function parseExifNumber(value) {
-  if (value === void 0) return void 0;
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  const parsed = Number.parseFloat(String(value).replace(/[^0-9.]/g, ""));
-  return Number.isFinite(parsed) ? parsed : void 0;
-}
-function normalizeExif(exif) {
-  if (!exif || Object.keys(exif).length === 0) return void 0;
-  const normalized = {
-    iso: parseExifNumber(exif.iso),
-    aperture: parseExifNumber(exif.aperture),
-    shutter: exif.shutter,
-    focalLength: parseExifNumber(exif.focalLength)
-  };
-  if (normalized.iso === void 0 && normalized.aperture === void 0 && !normalized.shutter && normalized.focalLength === void 0) {
-    return void 0;
-  }
-  return normalized;
-}
-function isSmugMugFlatExport(value) {
-  if (!value || typeof value !== "object") return false;
-  const record = value;
-  const version = record.exportVersion;
-  return (version === 1 || version === "1") && Array.isArray(record.Folders) && Array.isArray(record.Albums) && Array.isArray(record.Images);
-}
-function isSmugMugNestedExport(value) {
-  if (!value || typeof value !== "object") return false;
-  const record = value;
-  const version = record.exportVersion;
-  return (version === 1 || version === "1") && Array.isArray(record.folders);
-}
-async function loadSmugMugExport(options) {
-  if (options.data) return options.data;
-  if (!options.filePath) {
-    throw new Error("SmugMug parser requires filePath or data");
-  }
-  const raw = JSON.parse(await readFile2(options.filePath, "utf8"));
-  if (isSmugMugFlatExport(raw) || isSmugMugNestedExport(raw)) {
-    return raw;
-  }
-  throw new Error(
-    "Invalid SmugMug export: expected exportVersion 1 with folders[] (nested) or Folders/Albums/Images (flat)"
-  );
-}
-function resolveAssetUrl(image) {
-  if (image.originalUrl) return image.originalUrl;
-  return `${UNRESOLVED_URL_PREFIX}${image.sourceId}`;
-}
-function resolveFilename(image) {
-  if (image.fileName) return image.fileName;
-  return `${image.sourceId}.jpg`;
-}
-function* emitNestedFolderPortfolio(folder, exportedAt) {
-  yield {
-    type: "portfolio",
-    source: sourceMeta2(folder.id, void 0, exportedAt),
-    sourceId: folder.id,
-    title: folder.name,
-    slug: sanitizeSlug(folder.slug ?? folder.name),
-    description: folder.description
-  };
-}
-function* emitNestedAlbumPortfolio(folder, album, exportedAt) {
-  yield {
-    type: "portfolio",
-    source: sourceMeta2(album.id, album.url, exportedAt),
-    sourceId: album.id,
-    title: album.name,
-    slug: sanitizeSlug(album.slug ?? album.name),
-    description: album.description,
-    parentSourceId: folder.id
-  };
-}
-function* emitNestedAlbumAssets(album, exportedAt) {
-  for (let index = 0; index < album.images.length; index++) {
-    const image = album.images[index];
-    yield {
-      type: "asset",
-      source: sourceMeta2(image.id, image.originalUrl, exportedAt),
-      sourceId: image.id,
-      sourceUrl: image.originalUrl,
-      filename: image.fileName,
-      mimeType: guessMime2(image.fileName),
-      caption: image.caption,
-      keywords: image.keywords?.length ? image.keywords : void 0,
-      exif: normalizeExif(image.exif),
-      portfolioSourceId: album.id,
-      sort: index
-    };
-  }
-}
-async function* enumerateNestedExport(doc) {
-  const exportedAt = doc.exportedAt;
-  for (const folder of doc.folders) {
-    yield* emitNestedFolderPortfolio(folder, exportedAt);
-    for (const album of folder.albums) {
-      yield* emitNestedAlbumPortfolio(folder, album, exportedAt);
-      yield* emitNestedAlbumAssets(album, exportedAt);
-    }
-  }
-}
-async function* enumerateFlatExport(doc) {
-  const exportedAt = doc.exportedAt;
-  for (const folder of doc.Folders) {
-    yield {
-      type: "portfolio",
-      source: sourceMeta2(folder.sourceId, void 0, exportedAt),
-      sourceId: folder.sourceId,
-      title: folder.name,
-      slug: sanitizeSlug(folder.slug ?? folder.name),
-      description: folder.description,
-      parentSourceId: folder.parentSourceId
-    };
-  }
-  for (const album of doc.Albums) {
-    yield {
-      type: "portfolio",
-      source: sourceMeta2(album.sourceId, album.url, exportedAt),
-      sourceId: album.sourceId,
-      title: album.name,
-      slug: sanitizeSlug(album.slug ?? album.name),
-      description: album.description,
-      parentSourceId: album.parentSourceId
-    };
-  }
-  for (const image of doc.Images) {
-    const filename = resolveFilename(image);
-    yield {
-      type: "asset",
-      source: sourceMeta2(image.sourceId, image.originalUrl, exportedAt),
-      sourceId: image.sourceId,
-      sourceUrl: resolveAssetUrl(image),
-      filename,
-      mimeType: guessMime2(filename),
-      caption: image.caption,
-      keywords: image.keywords?.length ? image.keywords : void 0,
-      exif: normalizeExif(image.exif),
-      portfolioSourceId: image.portfolioSourceId,
-      sort: image.sort ?? 0
-    };
-  }
-}
-async function resolveSmugMugDocument(options) {
-  if (options.data) return options.data;
-  if (options.client) return options.client.crawlExport();
-  if (options.credentials) {
-    const client = new SmugMugApiClient({ credentials: options.credentials, ...options.clientOptions });
-    return client.crawlExport();
-  }
-  return loadSmugMugExport(options);
-}
-async function* enumerateSmugMugEntities(options) {
-  const doc = await resolveSmugMugDocument(options);
-  if (isSmugMugFlatExport(doc)) {
-    yield* enumerateFlatExport(doc);
-    return;
-  }
-  yield* enumerateNestedExport(doc);
-}
-function summarizeSmugMugExport(doc) {
-  if (isSmugMugFlatExport(doc)) {
-    return {
-      folders: doc.Folders.length,
-      albums: doc.Albums.length,
-      assets: doc.Images.length,
-      portfolios: doc.Folders.length + doc.Albums.length
-    };
-  }
-  const folders = doc.folders.length;
-  let albums = 0;
-  let assets = 0;
-  for (const folder of doc.folders) {
-    albums += folder.albums.length;
-    for (const album of folder.albums) {
-      assets += album.images.length;
-    }
-  }
-  return {
-    folders,
-    albums,
-    assets,
-    portfolios: folders + albums
-  };
-}
-async function validateSmugMugExportFile(filePath) {
-  const issues = [];
-  let doc;
-  try {
-    doc = await loadSmugMugExport({ filePath });
-  } catch (error) {
-    return {
-      ok: false,
-      issues: [
-        {
-          code: "invalid_export",
-          message: error instanceof Error ? error.message : String(error)
-        }
-      ],
-      summary: {}
-    };
-  }
-  if (isSmugMugFlatExport(doc)) {
-    if (doc.Folders.length === 0 && doc.Albums.length === 0) {
-      issues.push({ code: "empty_export", message: "No folders or albums in export" });
-    }
-  } else if (doc.folders.length === 0) {
-    issues.push({ code: "empty_export", message: "No folders in export" });
-  }
-  const summary = summarizeSmugMugExport(doc);
-  return {
-    ok: issues.length === 0,
-    issues,
-    summary: {
-      portfolios: summary.portfolios,
-      assets: summary.assets,
-      categories: summary.folders,
-      posts: 0,
-      pages: 0,
-      tags: 0
-    }
-  };
-}
-
-// src/parsers/smugmug/index.ts
-function resolveInput(input) {
-  if (typeof input === "string") return { path: input };
-  if (input && typeof input === "object") {
-    const record = input;
-    if (record.client || record.credentials || record.live) return record;
-    if (record.data) return { data: record.data };
-    if (record.path) return { path: record.path };
-  }
-  throw new Error(
-    "SmugMug adapter requires input path (string or { path }), { data }, { credentials }, { client }, or { live: true }"
-  );
-}
-function resolveLiveCredentials(input) {
-  if (input.credentials) return input.credentials;
-  if (input.live) return readSmugMugCredentialsFromEnv();
-  return void 0;
-}
-var smugmugAdapter = {
-  platform: "smugmug",
-  async validateInput(input) {
-    try {
-      const resolved = resolveInput(input);
-      const credentials = resolveLiveCredentials(resolved);
-      if (resolved.data) {
-        const summary = summarizeSmugMugExport(resolved.data);
-        return {
-          ok: true,
-          issues: [],
-          summary: {
-            portfolios: summary.portfolios,
-            assets: summary.assets,
-            categories: summary.folders,
-            posts: 0,
-            pages: 0,
-            tags: 0
-          }
-        };
-      }
-      if (resolved.client || credentials) {
-        const client = resolved.client ?? new SmugMugApiClient({ credentials, ...resolved.clientOptions });
-        await client.validateCredentials();
-        const doc = await client.crawlExport();
-        const summary = summarizeSmugMugExport(doc);
-        return {
-          ok: true,
-          issues: [],
-          summary: {
-            portfolios: summary.portfolios,
-            assets: summary.assets,
-            categories: summary.folders,
-            posts: 0,
-            pages: 0,
-            tags: 0
-          }
-        };
-      }
-      const result = await validateSmugMugExportFile(resolved.path);
-      return {
-        ok: result.ok,
-        issues: result.issues,
-        summary: result.summary
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        issues: [
-          {
-            code: "invalid_input",
-            message: error instanceof Error ? error.message : String(error)
-          }
-        ]
-      };
-    }
-  },
-  enumerateEntities(ctx) {
-    const resolved = resolveInput(ctx.input);
-    const credentials = resolveLiveCredentials(resolved);
-    return enumerateSmugMugEntities({
-      filePath: resolved.path,
-      data: resolved.data,
-      client: resolved.client,
-      credentials,
-      clientOptions: resolved.clientOptions
-    });
-  }
-};
-
-// src/parsers/squarespace/index.ts
-function resolveInput2(input) {
-  if (typeof input === "string") return { path: input };
-  if (input && typeof input === "object") {
-    const record = input;
-    if (record.client || record.collectTargets) return record;
-    if (record.data) return { data: record.data };
-    if (record.path) return { path: record.path };
-  }
-  throw new Error(
-    "Squarespace adapter requires input path (string or { path }), { data }, { client, collectTargets }, or { collectTargets }"
-  );
-}
-var squarespaceAdapter = {
-  platform: "squarespace",
-  async validateInput(input) {
-    try {
-      const resolved = resolveInput2(input);
-      if (resolved.data) {
-        const summary = summarizeSquarespaceExport(resolved.data);
-        return {
-          ok: true,
-          issues: [],
-          summary: {
-            pages: summary.pages,
-            posts: summary.posts,
-            categories: summary.categories,
-            tags: summary.tags
-          }
-        };
-      }
-      if (resolved.client || resolved.collectTargets?.length) {
-        if (!resolved.collectTargets?.length) {
-          throw new Error("Squarespace live validation requires collectTargets");
-        }
-        const client = resolved.client ?? new SquarespaceCollectionClient(resolved.clientOptions);
-        const doc = await client.collectExport(resolved.collectTargets);
-        const summary = summarizeSquarespaceExport(doc);
-        return {
-          ok: true,
-          issues: [],
-          summary: {
-            pages: summary.pages,
-            posts: summary.posts,
-            categories: summary.categories,
-            tags: summary.tags
-          }
-        };
-      }
-      const result = await validateSquarespaceExportFile(resolved.path);
-      return {
-        ok: result.ok,
-        issues: result.issues,
-        summary: result.summary
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        issues: [
-          {
-            code: "invalid_input",
-            message: error instanceof Error ? error.message : String(error)
-          }
-        ]
-      };
-    }
-  },
-  enumerateEntities(ctx) {
-    const resolved = resolveInput2(ctx.input);
-    return enumerateSquarespaceEntities({
-      filePath: resolved.path,
-      data: resolved.data,
-      client: resolved.client,
-      collectTargets: resolved.collectTargets,
-      clientOptions: resolved.clientOptions
-    });
-  }
-};
-
-// src/parsers/index.ts
-var adapters = {
-  wordpress: wordpressAdapter,
-  smugmug: smugmugAdapter,
-  squarespace: squarespaceAdapter
-};
-function getAdapter(platform) {
-  return adapters[platform];
-}
-
-export {
-  wordpressAdapter,
-  SMUGMUG_API_BASE,
-  SMUGMUG_OAUTH_ENDPOINTS,
-  smugMugCredentialsSchema,
-  signSmugMugOAuthRequest,
-  buildSmugMugAuthorizationHeader,
-  readSmugMugCredentialsFromEnv,
-  SmugMugApiClient,
-  smugmugAdapter,
-  squarespaceAdapter,
-  getAdapter
-};
-//# sourceMappingURL=chunk-FXXKLYO5.js.map