@yuiseki/gyazocli 0.0.2 → 0.2.0

package/dist/dates.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * Dates, as this CLI means them: a day is a local day, because that is how the
+ * cache is laid out and how a person asking for "today" means it. Parses what
+ * --date and --days accept, builds the ranges the aggregations walk, and keys
+ * the hourly cache buckets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATE_OPTION_PROBLEMS = exports.WEEKDAY_LABELS = void 0;
+exports.isToday = isToday;
+exports.parseUploadTimestamp = parseUploadTimestamp;
+exports.tryParseDateOption = tryParseDateOption;
+exports.parseDateOption = parseDateOption;
+exports.formatDateYmd = formatDateYmd;
+exports.buildRecentWeekRangeUntilYesterday = buildRecentWeekRangeUntilYesterday;
+exports.resolveRankingRangeOption = resolveRankingRangeOption;
+exports.buildStatsDateRange = buildStatsDateRange;
+exports.getDateHourStrings = getDateHourStrings;
+exports.buildHourlyBucketKey = buildHourlyBucketKey;
+exports.splitHourlyBucketKey = splitHourlyBucketKey;
+exports.toDateParts = toDateParts;
+exports.getDatePartsInRange = getDatePartsInRange;
+exports.parseHourOption = parseHourOption;
+const options_1 = require("./options");
+exports.WEEKDAY_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+function isToday(date) {
+    const today = new Date();
+    return date.getDate() === today.getDate() &&
+        date.getMonth() === today.getMonth() &&
+        date.getFullYear() === today.getFullYear();
+}
+function parseUploadTimestamp(value) {
+    if (!value)
+        return undefined;
+    if (!/^\d+$/.test(value)) {
+        console.error('Error: --timestamp must be a unix timestamp in seconds.');
+        process.exit(1);
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        console.error('Error: --timestamp is out of range.');
+        process.exit(1);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    if (parsed > now) {
+        console.error('Error: --timestamp must be current time or in the past.');
+        process.exit(1);
+    }
+    return parsed;
+}
+/**
+ * Reads a date the way --date accepts it, without deciding what to do when it
+ * cannot: the CLI reports and exits, the MCP server throws.
+ */
+function tryParseDateOption(value) {
+    if (!value) {
+        const today = new Date();
+        const year = String(today.getFullYear());
+        const month = String(today.getMonth() + 1).padStart(2, '0');
+        const day = String(today.getDate()).padStart(2, '0');
+        return {
+            ok: true,
+            value: {
+                granularity: 'day',
+                dateKey: `${year}-${month}-${day}`,
+                start: new Date(today.getFullYear(), today.getMonth(), today.getDate(), 0, 0, 0, 0),
+                end: new Date(today.getFullYear(), today.getMonth(), today.getDate(), 23, 59, 59, 999),
+            },
+        };
+    }
+    if (/^\d{4}$/.test(value)) {
+        const year = Number(value);
+        return {
+            ok: true,
+            value: {
+                granularity: 'year',
+                dateKey: value,
+                start: new Date(year, 0, 1, 0, 0, 0, 0),
+                end: new Date(year, 11, 31, 23, 59, 59, 999),
+            },
+        };
+    }
+    if (/^\d{4}-\d{2}$/.test(value)) {
+        const [yearText, monthText] = value.split('-');
+        const year = Number(yearText);
+        const month = Number(monthText);
+        const probe = new Date(year, month - 1, 1);
+        if (probe.getFullYear() !== year || probe.getMonth() !== month - 1) {
+            return { ok: false, problem: 'month' };
+        }
+        return {
+            ok: true,
+            value: {
+                granularity: 'month',
+                dateKey: value,
+                start: new Date(year, month - 1, 1, 0, 0, 0, 0),
+                end: new Date(year, month, 0, 23, 59, 59, 999),
+            },
+        };
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        const [yearText, monthText, dayText] = value.split('-');
+        const year = Number(yearText);
+        const month = Number(monthText);
+        const day = Number(dayText);
+        const probe = new Date(year, month - 1, day);
+        if (probe.getFullYear() !== year ||
+            probe.getMonth() !== month - 1 ||
+            probe.getDate() !== day) {
+            return { ok: false, problem: 'day' };
+        }
+        return {
+            ok: true,
+            value: {
+                granularity: 'day',
+                dateKey: value,
+                start: new Date(year, month - 1, day, 0, 0, 0, 0),
+                end: new Date(year, month - 1, day, 23, 59, 59, 999),
+            },
+        };
+    }
+    return { ok: false, problem: 'format' };
+}
+exports.DATE_OPTION_PROBLEMS = {
+    month: '--date month is invalid.',
+    day: '--date day is invalid.',
+    format: '--date format must be yyyy or yyyy-mm or yyyy-mm-dd.',
+};
+function parseDateOption(value) {
+    const parsed = tryParseDateOption(value);
+    if (!parsed.ok) {
+        console.error(`Error: ${exports.DATE_OPTION_PROBLEMS[parsed.problem]}`);
+        process.exit(1);
+    }
+    return parsed.value;
+}
+function formatDateYmd(date) {
+    const year = String(date.getFullYear());
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function buildRecentWeekRangeUntilYesterday() {
+    const today = new Date();
+    const end = new Date(today.getFullYear(), today.getMonth(), today.getDate() - 1, 23, 59, 59, 999);
+    const start = new Date(today.getFullYear(), today.getMonth(), today.getDate() - 8, 0, 0, 0, 0);
+    return {
+        granularity: 'day',
+        dateKey: `${formatDateYmd(start)}..${formatDateYmd(end)}`,
+        start,
+        end,
+    };
+}
+function resolveRankingRangeOption(options) {
+    if (options.today && options.date) {
+        console.error('Error: --today and --date cannot be used together.');
+        process.exit(1);
+    }
+    if (options.today) {
+        return parseDateOption();
+    }
+    if (options.date) {
+        return parseDateOption(options.date);
+    }
+    return buildRecentWeekRangeUntilYesterday();
+}
+function buildStatsDateRange(dateOption, daysOption) {
+    if (!dateOption && daysOption === '7') {
+        const weekly = buildRecentWeekRangeUntilYesterday();
+        return {
+            range: weekly,
+            days: 7,
+            startLabel: formatDateYmd(weekly.start),
+            endLabel: formatDateYmd(weekly.end),
+        };
+    }
+    const days = (0, options_1.parsePositiveIntegerOption)(daysOption, '--days');
+    let endDate;
+    if (dateOption) {
+        const parsed = parseDateOption(dateOption);
+        endDate = new Date(parsed.end);
+    }
+    else {
+        const now = new Date();
+        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1, 23, 59, 59, 999);
+    }
+    const startDate = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate(), 0, 0, 0, 0);
+    startDate.setDate(startDate.getDate() - (days - 1));
+    const startLabel = formatDateYmd(startDate);
+    const endLabel = formatDateYmd(endDate);
+    return {
+        range: {
+            granularity: 'day',
+            dateKey: `${startLabel}..${endLabel}`,
+            start: startDate,
+            end: endDate,
+        },
+        days,
+        startLabel,
+        endLabel,
+    };
+}
+function getDateHourStrings() {
+    const hours = [];
+    for (let hour = 0; hour < 24; hour++) {
+        hours.push(String(hour).padStart(2, '0'));
+    }
+    return hours;
+}
+function buildHourlyBucketKey(year, month, day, hour) {
+    return `${year}-${month}-${day}-${hour}`;
+}
+function splitHourlyBucketKey(key) {
+    const [year, month, day, hour] = key.split('-');
+    return { year, month, day, hour };
+}
+function toDateParts(date) {
+    return {
+        year: String(date.getFullYear()),
+        month: String(date.getMonth() + 1).padStart(2, '0'),
+        day: String(date.getDate()).padStart(2, '0'),
+        hour: String(date.getHours()).padStart(2, '0'),
+    };
+}
+function getDatePartsInRange(start, end) {
+    const dates = [];
+    const cursor = new Date(start.getFullYear(), start.getMonth(), start.getDate(), 0, 0, 0, 0);
+    const last = new Date(end.getFullYear(), end.getMonth(), end.getDate(), 0, 0, 0, 0);
+    while (cursor.getTime() <= last.getTime()) {
+        dates.push({
+            year: String(cursor.getFullYear()),
+            month: String(cursor.getMonth() + 1).padStart(2, '0'),
+            day: String(cursor.getDate()).padStart(2, '0'),
+        });
+        cursor.setDate(cursor.getDate() + 1);
+    }
+    return dates;
+}
+/**
+ * `yyyy-mm-dd-hh`, the shape the hourly cache is keyed by. Returns null rather
+ * than reporting, because how to report differs between the CLI and the MCP
+ * server.
+ */
+function parseHourOption(value) {
+    const parts = (value || '').split('-');
+    if (parts.length !== 4)
+        return null;
+    const [year, month, day, hour] = parts;
+    return { year, month, day, hour };
+}

package/dist/format.js

@@ -0,0 +1,375 @@
+"use strict";
+/**
+ * Reading and presenting the fields of a Gyazo image: the domain a capture
+ * came from, the address recorded in its EXIF, its OCR text, the objects
+ * detected in it. Nothing here talks to the API or the cache, so both the CLI
+ * and the aggregations can share it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeText = normalizeText;
+exports.extractDomain = extractDomain;
+exports.isXDomain = isXDomain;
+exports.cleanTextForDomain = cleanTextForDomain;
+exports.stripInlineUrls = stripInlineUrls;
+exports.sanitizeSummaryText = sanitizeSummaryText;
+exports.getAddressEntry = getAddressEntry;
+exports.getAddressComponent = getAddressComponent;
+exports.buildJaLocationLabel = buildJaLocationLabel;
+exports.buildEnLocationLabel = buildEnLocationLabel;
+exports.extractImageAddressText = extractImageAddressText;
+exports.extractImageLocationLabel = extractImageLocationLabel;
+exports.truncateText = truncateText;
+exports.formatCreatedAt = formatCreatedAt;
+exports.shortenImageId = shortenImageId;
+exports.formatTerminalLink = formatTerminalLink;
+exports.normalizeOcrText = normalizeOcrText;
+exports.extractOcrDescription = extractOcrDescription;
+exports.buildOcrPreview = buildOcrPreview;
+exports.extractObjectAnnotations = extractObjectAnnotations;
+exports.formatObjectAnnotationLine = formatObjectAnnotationLine;
+exports.extractImageApps = extractImageApps;
+exports.extractImageDomains = extractImageDomains;
+exports.extractImageLocations = extractImageLocations;
+exports.normalizeTagText = normalizeTagText;
+exports.extractTagFromLinkValue = extractTagFromLinkValue;
+exports.extractImageTags = extractImageTags;
+exports.normalizeRankingValues = normalizeRankingValues;
+exports.shouldEnrichForLocationDisplay = shouldEnrichForLocationDisplay;
+exports.mergeImageForDisplay = mergeImageForDisplay;
+function normalizeText(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function extractDomain(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        return url.hostname.replace(/^www\./, '');
+    }
+    catch (e) {
+        try {
+            const url = new URL(`https://${value}`);
+            return url.hostname.replace(/^www\./, '');
+        }
+        catch (_e) {
+            return undefined;
+        }
+    }
+}
+function isXDomain(domain) {
+    if (!domain)
+        return false;
+    return domain === 'x.com' ||
+        domain.endsWith('.x.com') ||
+        domain === 'twitter.com' ||
+        domain.endsWith('.twitter.com');
+}
+function cleanTextForDomain(value, domain) {
+    if (!isXDomain(domain))
+        return value;
+    return value
+        .replace(/^Xユーザーの/, '')
+        .replace(/\s*\/\s*X$/, '')
+        .trim();
+}
+function stripInlineUrls(value) {
+    return value
+        .replace(/https?:\/\/\S+/g, '')
+        .replace(/\bwww\.\S+/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function sanitizeSummaryText(value, domain) {
+    if (!value)
+        return undefined;
+    return normalizeText(stripInlineUrls(cleanTextForDomain(value, domain)));
+}
+function getAddressEntry(exifAddress, locale) {
+    if (!exifAddress || typeof exifAddress !== 'object')
+        return undefined;
+    if (typeof exifAddress.address === 'string')
+        return exifAddress;
+    const entry = exifAddress[locale];
+    if (!entry || typeof entry !== 'object')
+        return undefined;
+    return entry;
+}
+function getAddressComponent(addressEntry, type) {
+    if (!addressEntry || typeof addressEntry !== 'object')
+        return undefined;
+    const components = Array.isArray(addressEntry.address_components)
+        ? addressEntry.address_components
+        : [];
+    for (const component of components) {
+        if (!component || typeof component !== 'object')
+            continue;
+        const types = Array.isArray(component.types) ? component.types : [];
+        if (!types.includes(type))
+            continue;
+        const value = normalizeText(component.long_name || component.short_name);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function buildJaLocationLabel(exifAddress) {
+    const ja = getAddressEntry(exifAddress, 'ja');
+    if (!ja)
+        return undefined;
+    const pref = getAddressComponent(ja, 'administrative_area_level_1');
+    const locality = getAddressComponent(ja, 'locality') || getAddressComponent(ja, 'administrative_area_level_2');
+    const sublocality = getAddressComponent(ja, 'sublocality_level_2') ||
+        getAddressComponent(ja, 'sublocality_level_1') ||
+        getAddressComponent(ja, 'sublocality_level_3');
+    const fromComponents = normalizeText([pref, locality, sublocality].filter(Boolean).join(''));
+    if (fromComponents)
+        return fromComponents;
+    const raw = normalizeText(ja.address);
+    if (!raw)
+        return undefined;
+    const compact = raw
+        .replace(/^日本、?/, '')
+        .replace(/〒\d{3}-\d{4}\s*/g, '')
+        .replace(/[0-9０-９].*$/, '')
+        .trim();
+    return normalizeText(compact);
+}
+function buildEnLocationLabel(exifAddress) {
+    const en = getAddressEntry(exifAddress, 'en');
+    if (!en)
+        return undefined;
+    const pref = getAddressComponent(en, 'administrative_area_level_1');
+    const locality = getAddressComponent(en, 'locality') || getAddressComponent(en, 'administrative_area_level_2');
+    const sublocality = getAddressComponent(en, 'sublocality_level_2') ||
+        getAddressComponent(en, 'sublocality_level_1') ||
+        getAddressComponent(en, 'sublocality_level_3');
+    const fromComponents = normalizeText([sublocality, locality, pref].filter(Boolean).join(', '));
+    if (fromComponents)
+        return fromComponents;
+    return normalizeText(en.address);
+}
+function extractImageAddressText(img) {
+    const exifAddress = img.metadata?.exif_address ?? img.exif_address;
+    if (!exifAddress)
+        return undefined;
+    if (typeof exifAddress === 'string')
+        return normalizeText(exifAddress);
+    if (typeof exifAddress !== 'object')
+        return undefined;
+    const ja = getAddressEntry(exifAddress, 'ja');
+    const jaAddress = normalizeText(ja?.address);
+    if (jaAddress)
+        return jaAddress;
+    const en = getAddressEntry(exifAddress, 'en');
+    const enAddress = normalizeText(en?.address);
+    if (enAddress)
+        return enAddress;
+    for (const value of Object.values(exifAddress)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const raw = normalizeText(value.address);
+        if (raw)
+            return raw;
+    }
+    return undefined;
+}
+function extractImageLocationLabel(img) {
+    const exifAddress = img.metadata?.exif_address ?? img.exif_address;
+    if (!exifAddress)
+        return undefined;
+    if (typeof exifAddress === 'string')
+        return normalizeText(exifAddress);
+    if (typeof exifAddress !== 'object')
+        return undefined;
+    const jaLabel = buildJaLocationLabel(exifAddress);
+    if (jaLabel)
+        return jaLabel;
+    const enLabel = buildEnLocationLabel(exifAddress);
+    if (enLabel)
+        return enLabel;
+    for (const value of Object.values(exifAddress)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const raw = normalizeText(value.address);
+        if (raw)
+            return raw;
+    }
+    return undefined;
+}
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 3)
+        return value.slice(0, maxLength);
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+function formatCreatedAt(value) {
+    const match = value.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}):(\d{2})/);
+    if (match) {
+        return `${match[1]} ${match[2]}:${match[3]}`;
+    }
+    return value;
+}
+function shortenImageId(imageId) {
+    if (!imageId)
+        return '';
+    if (imageId.length <= 4)
+        return imageId;
+    return `${imageId.slice(0, 4)}...`;
+}
+function formatTerminalLink(label, url) {
+    if (!url || !process.stdout.isTTY)
+        return label;
+    return `\u001B]8;;${url}\u0007${label}\u001B]8;;\u0007`;
+}
+function normalizeOcrText(value) {
+    if (!value)
+        return undefined;
+    const normalized = value
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .map(line => line.trimEnd())
+        .join('\n')
+        .trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function extractOcrDescription(image) {
+    const direct = normalizeOcrText(image?.ocr?.description);
+    if (direct)
+        return direct;
+    return normalizeOcrText(image?.metadata?.ocr?.description);
+}
+function buildOcrPreview(ocrText, maxLines) {
+    const lines = ocrText.split('\n');
+    if (lines.length <= maxLines) {
+        return { text: ocrText, truncated: false };
+    }
+    return {
+        text: lines.slice(0, maxLines).join('\n'),
+        truncated: true,
+    };
+}
+function extractObjectAnnotations(image) {
+    const rawAnnotations = image?.localizedObjectAnnotations ||
+        image?.localized_object_annotations ||
+        image?.metadata?.localizedObjectAnnotations ||
+        image?.metadata?.localized_object_annotations ||
+        [];
+    if (!Array.isArray(rawAnnotations))
+        return [];
+    const bestByName = new Map();
+    for (const annotation of rawAnnotations) {
+        if (!annotation || typeof annotation !== 'object')
+            continue;
+        const name = normalizeText(annotation.name_ja || annotation.nameJa || annotation.name);
+        if (!name)
+            continue;
+        const score = typeof annotation.score === 'number' ? annotation.score : undefined;
+        const existing = bestByName.get(name);
+        if (!existing) {
+            bestByName.set(name, { name, score });
+            continue;
+        }
+        const existingScore = existing.score ?? -1;
+        const nextScore = score ?? -1;
+        if (nextScore > existingScore) {
+            bestByName.set(name, { name, score });
+        }
+    }
+    return Array.from(bestByName.values()).sort((a, b) => {
+        const sa = a.score ?? -1;
+        const sb = b.score ?? -1;
+        return sb - sa;
+    });
+}
+function formatObjectAnnotationLine(annotation) {
+    if (typeof annotation.score === 'number') {
+        return `${annotation.name} (${(annotation.score * 100).toFixed(1)}%)`;
+    }
+    return annotation.name;
+}
+function extractImageApps(image) {
+    const app = normalizeText(image?.metadata?.app);
+    return app ? [app] : [];
+}
+function extractImageDomains(image) {
+    const domain = extractDomain(normalizeText(image?.metadata?.url));
+    return domain ? [domain] : [];
+}
+function extractImageLocations(image) {
+    const location = normalizeText(extractImageLocationLabel(image));
+    return location ? [location] : [];
+}
+function normalizeTagText(value) {
+    if (!value)
+        return undefined;
+    const normalized = normalizeText(value);
+    if (!normalized)
+        return undefined;
+    const stripped = normalized.replace(/^[#＃]+/, '').trim();
+    return stripped.length > 0 ? stripped : undefined;
+}
+function extractTagFromLinkValue(value) {
+    if (typeof value === 'string') {
+        return normalizeTagText(value);
+    }
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidates = [
+        value.tag,
+        value.name,
+        value.title,
+        value.text,
+        value.keyword,
+    ];
+    for (const candidate of candidates) {
+        const tag = normalizeTagText(candidate);
+        if (tag)
+            return tag;
+    }
+    return undefined;
+}
+function extractImageTags(image) {
+    const rawLinks = image?.metadata?.links ?? image?.links;
+    if (!Array.isArray(rawLinks))
+        return [];
+    const tags = [];
+    for (const rawLink of rawLinks) {
+        const tag = extractTagFromLinkValue(rawLink);
+        if (tag)
+            tags.push(tag);
+    }
+    return normalizeRankingValues(tags);
+}
+function normalizeRankingValues(values) {
+    const uniqueByLower = new Map();
+    for (const raw of values) {
+        const value = normalizeText(raw);
+        if (!value)
+            continue;
+        const key = value.toLocaleLowerCase();
+        if (!uniqueByLower.has(key)) {
+            uniqueByLower.set(key, value);
+        }
+    }
+    return Array.from(uniqueByLower.values());
+}
+function shouldEnrichForLocationDisplay(img) {
+    const locationLabel = sanitizeSummaryText(extractImageLocationLabel(img));
+    return !locationLabel;
+}
+function mergeImageForDisplay(base, detail) {
+    return {
+        ...base,
+        ...detail,
+        metadata: {
+            ...(base?.metadata || {}),
+            ...(detail?.metadata || {}),
+        },
+        ocr: detail?.ocr ?? base?.ocr,
+    };
+}

package/dist/ids.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Turning what a human or an agent typed into a Gyazo ID. Kept apart from the
+ * CLI itself so that other entry points, such as the MCP server, can reuse it
+ * without loading commander and its commands.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeImageId = normalizeImageId;
+exports.normalizeCollectionId = normalizeCollectionId;
+const IMAGE_ID_PATTERN = /^[0-9a-f]{32}$/i;
+const GYAZO_HOST_PATTERN = /(^|\.)gyazo\.com$/i;
+/**
+ * Accept either a bare Gyazo image id (32 hex characters) or any Gyazo URL that
+ * carries one, and return the canonical lowercase id. Returns null otherwise.
+ */
+function normalizeImageId(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed)
+        return null;
+    if (IMAGE_ID_PATTERN.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!GYAZO_HOST_PATTERN.test(url.hostname)) {
+        return null;
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment)
+        return null;
+    // /collections/<id> is a collection, not an image.
+    if (segments[segments.length - 2] === 'collections')
+        return null;
+    const withoutExtension = lastSegment.replace(/\.[a-z0-9]+$/i, '');
+    return IMAGE_ID_PATTERN.test(withoutExtension) ? withoutExtension.toLowerCase() : null;
+}
+/**
+ * A collection ID looks exactly like an image ID (32 hex characters), so only
+ * the URL form tells the two apart. `/collections/<id>` is a collection;
+ * `/<id>` is an image.
+ */
+function normalizeCollectionId(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed)
+        return null;
+    if (IMAGE_ID_PATTERN.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!GYAZO_HOST_PATTERN.test(url.hostname)) {
+        return null;
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    if (segments.length < 2 || segments[segments.length - 2] !== 'collections') {
+        return null;
+    }
+    const withoutExtension = segments[segments.length - 1].replace(/\.[a-z0-9]+$/i, '');
+    return IMAGE_ID_PATTERN.test(withoutExtension) ? withoutExtension.toLowerCase() : null;
+}