@songmu/mdhq 0.0.2

package/dist/convert/extract-updated.d.ts

@@ -0,0 +1,8 @@
+import { type ArticleDocument } from "./article-date.js";
+/**
+ * Extracts and normalizes the article modification ("updated") date from
+ * Schema.org `dateModified` JSON-LD, `article:modified_time` /
+ * `og:updated_time` meta tags, or `itemprop="dateModified"` microdata.
+ */
+export declare function extractUpdatedDate(html: string, pageUrl?: string): string | undefined;
+export declare function extractUpdatedDateFromDocument(document: ArticleDocument, pageUrl?: string): string | undefined;

package/dist/convert/extract-updated.js

@@ -0,0 +1,20 @@
+import { extractArticleDate, extractArticleDateFromDocument } from "./article-date.js";
+/**
+ * Extracts and normalizes the article modification ("updated") date from
+ * Schema.org `dateModified` JSON-LD, `article:modified_time` /
+ * `og:updated_time` meta tags, or `itemprop="dateModified"` microdata.
+ */
+export function extractUpdatedDate(html, pageUrl) {
+    return extractArticleDate(html, {
+        schemaProperty: "dateModified",
+        metaProperties: ["article:modified_time", "og:updated_time"],
+        itemprops: ["dateModified"]
+    }, pageUrl);
+}
+export function extractUpdatedDateFromDocument(document, pageUrl) {
+    return extractArticleDateFromDocument(document, {
+        schemaProperty: "dateModified",
+        metaProperties: ["article:modified_time", "og:updated_time"],
+        itemprops: ["dateModified"]
+    }, pageUrl);
+}

package/dist/date.d.ts

@@ -0,0 +1,18 @@
+export declare function formatLocalRfc3339(date: Date): string;
+/**
+ * Normalizes heterogeneous source-article date metadata (published/updated)
+ * into exactly one of:
+ * - `YYYY-MM-DD`, when only a calendar date is reliably known, or
+ * - an RFC 3339 date-time with an explicit `Z` or numeric offset and
+ *   second-level precision.
+ *
+ * Accepts strings, finite integer numbers (interpreted as Unix epoch
+ * seconds/milliseconds/microseconds/nanoseconds based on magnitude), JSON-LD
+ * value objects (`{"@value": ..., "@type": ...}`), and arrays of candidates
+ * (the first value that normalizes successfully is used). Unsupported or
+ * ambiguous shapes return `undefined` instead of throwing or guessing.
+ */
+export declare function normalizeSourceDate(value: unknown): string | undefined;
+export declare function isRfc3339DateTime(value: string | undefined): value is string;
+export declare function httpDateToRfc3339(value: string | undefined, now?: Date): string | undefined;
+export declare function rfc3339ToHttpDate(value: string | undefined): string | undefined;

package/dist/date.js

@@ -0,0 +1,448 @@
+const RFC3339_DATE = /^(\d{4})-(\d{2})-(\d{2})$/u;
+const RFC3339_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|([+-])(\d{2}):(\d{2}))$/iu;
+const COMPACT_DATE = /^(\d{4})(\d{2})(\d{2})$/u;
+const INTEGER_STRING = /^[+-]?\d+$/u;
+// A space separator is accepted only alongside an explicit zone; a bare
+// space-separated local date-time without a zone is handled by
+// LOCAL_DATE_TIME below and reduced to a date-only value.
+const ZONED_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(Z|[+-]\d{2}:?\d{2})$/iu;
+const LOCAL_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/u;
+const MONTH_DAY_YEAR = /^([A-Za-z]{3,9})\.?\s+(\d{1,2}),?\s+(\d{4})$/u;
+const DAY_MONTH_YEAR = /^(\d{1,2})\s+([A-Za-z]{3,9})\.?,?\s+(\d{4})$/u;
+const MAX_SAFE_DATE_MS = 8640000000000000n;
+const IMF_FIXDATE = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{2}):(\d{2}):(\d{2}) GMT$/u;
+const RFC850_DATE = /^(Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{2}):(\d{2}):(\d{2}) GMT$/u;
+const ASCTIME_DATE = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) {1,2}(\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/u;
+const MONTHS = new Map(["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].map((month, index) => [month, index + 1]));
+const MONTH_FULL_NAMES = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december"
+];
+const MONTH_NAME_TO_NUMBER = new Map();
+for (const [index, name] of MONTH_FULL_NAMES.entries()) {
+    MONTH_NAME_TO_NUMBER.set(name, index + 1);
+    MONTH_NAME_TO_NUMBER.set(name.slice(0, 3), index + 1);
+}
+const SHORT_WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const LONG_WEEKDAYS = [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+];
+function capture(match, index) {
+    const value = match[index];
+    if (value === undefined) {
+        throw new TypeError(`Missing regular expression capture ${index}`);
+    }
+    return value;
+}
+function leapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function validCalendarDate(year, month, day) {
+    const days = [31, leapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (days[month - 1] ?? 0);
+}
+function validTime(hour, minute, second) {
+    return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+}
+function utcTimestamp(year, month, day, hour, minute, second) {
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    date.setUTCHours(hour, minute, second, 0);
+    return date.getTime();
+}
+function validWeekday(timestamp, value, long) {
+    const expected = (long ? LONG_WEEKDAYS : SHORT_WEEKDAYS)[new Date(timestamp).getUTCDay()];
+    return value === expected;
+}
+function parseRfc3339(value) {
+    const match = RFC3339_DATE_TIME.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    const yearValue = capture(match, 1);
+    const monthValue = capture(match, 2);
+    const dayValue = capture(match, 3);
+    const hourValue = capture(match, 4);
+    const minuteValue = capture(match, 5);
+    const secondValue = capture(match, 6);
+    const zone = capture(match, 7);
+    const year = Number(yearValue);
+    const month = Number(monthValue);
+    const day = Number(dayValue);
+    const hour = Number(hourValue);
+    const minute = Number(minuteValue);
+    const second = Number(secondValue);
+    if (!validCalendarDate(year, month, day) || !validTime(hour, minute, second)) {
+        return undefined;
+    }
+    let offsetMinutes = 0;
+    if (zone.toUpperCase() !== "Z") {
+        const offsetSign = capture(match, 8);
+        const offsetHour = Number(capture(match, 9));
+        const offsetMinute = Number(capture(match, 10));
+        if (offsetHour > 23 || offsetMinute > 59) {
+            return undefined;
+        }
+        offsetMinutes = (offsetHour * 60 + offsetMinute) * (offsetSign === "+" ? 1 : -1);
+    }
+    return utcTimestamp(year, month, day, hour, minute, second) - offsetMinutes * 60_000;
+}
+function parseHttpDate(value, now) {
+    const imf = IMF_FIXDATE.exec(value);
+    if (imf) {
+        const weekday = capture(imf, 1);
+        const dayValue = capture(imf, 2);
+        const monthName = capture(imf, 3);
+        const yearValue = capture(imf, 4);
+        const hourValue = capture(imf, 5);
+        const minuteValue = capture(imf, 6);
+        const secondValue = capture(imf, 7);
+        const month = MONTHS.get(monthName) ?? 0;
+        const values = [
+            Number(yearValue),
+            month,
+            Number(dayValue),
+            Number(hourValue),
+            Number(minuteValue),
+            Number(secondValue)
+        ];
+        if (!validCalendarDate(values[0], values[1], values[2]) || !validTime(values[3], values[4], values[5])) {
+            return undefined;
+        }
+        const timestamp = utcTimestamp(...values);
+        return validWeekday(timestamp, weekday, false) ? timestamp : undefined;
+    }
+    const rfc850 = RFC850_DATE.exec(value);
+    if (rfc850) {
+        const weekday = capture(rfc850, 1);
+        const dayValue = capture(rfc850, 2);
+        const monthName = capture(rfc850, 3);
+        const shortYearValue = capture(rfc850, 4);
+        const hourValue = capture(rfc850, 5);
+        const minuteValue = capture(rfc850, 6);
+        const secondValue = capture(rfc850, 7);
+        const month = MONTHS.get(monthName) ?? 0;
+        const currentYear = now.getUTCFullYear();
+        let year = Math.floor(currentYear / 100) * 100 + Number(shortYearValue);
+        const candidateValues = [
+            year,
+            month,
+            Number(dayValue),
+            Number(hourValue),
+            Number(minuteValue),
+            Number(secondValue)
+        ];
+        if (!validCalendarDate(candidateValues[0], candidateValues[1], candidateValues[2]) ||
+            !validTime(candidateValues[3], candidateValues[4], candidateValues[5])) {
+            return undefined;
+        }
+        const cutoff = new Date(now.getTime());
+        cutoff.setUTCFullYear(cutoff.getUTCFullYear() + 50);
+        if (utcTimestamp(...candidateValues) > cutoff.getTime()) {
+            year -= 100;
+        }
+        const values = [
+            year,
+            month,
+            Number(dayValue),
+            Number(hourValue),
+            Number(minuteValue),
+            Number(secondValue)
+        ];
+        const timestamp = utcTimestamp(...values);
+        return validWeekday(timestamp, weekday, true) ? timestamp : undefined;
+    }
+    const asctime = ASCTIME_DATE.exec(value);
+    if (!asctime) {
+        return undefined;
+    }
+    const weekday = capture(asctime, 1);
+    const monthName = capture(asctime, 2);
+    const dayValue = capture(asctime, 3);
+    const hourValue = capture(asctime, 4);
+    const minuteValue = capture(asctime, 5);
+    const secondValue = capture(asctime, 6);
+    const yearValue = capture(asctime, 7);
+    const month = MONTHS.get(monthName) ?? 0;
+    const values = [
+        Number(yearValue),
+        month,
+        Number(dayValue),
+        Number(hourValue),
+        Number(minuteValue),
+        Number(secondValue)
+    ];
+    if (!validCalendarDate(values[0], values[1], values[2]) || !validTime(values[3], values[4], values[5])) {
+        return undefined;
+    }
+    const timestamp = utcTimestamp(...values);
+    return validWeekday(timestamp, weekday, false) ? timestamp : undefined;
+}
+export function formatLocalRfc3339(date) {
+    const pad = (value, width = 2) => String(value).padStart(width, "0");
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const hours = Math.floor(Math.abs(offsetMinutes) / 60);
+    const minutes = Math.abs(offsetMinutes) % 60;
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}${sign}${pad(hours)}:${pad(minutes)}`;
+}
+function monthNumber(name) {
+    return MONTH_NAME_TO_NUMBER.get(name.toLowerCase());
+}
+function parseZoneOffset(zone) {
+    if (zone.toUpperCase() === "Z") {
+        return { canonical: "Z" };
+    }
+    const match = /^([+-])(\d{2}):?(\d{2})$/u.exec(zone);
+    if (!match) {
+        return undefined;
+    }
+    const sign = capture(match, 1);
+    const hour = Number(capture(match, 2));
+    const minute = Number(capture(match, 3));
+    if (hour > 23 || minute > 59) {
+        return undefined;
+    }
+    return { canonical: `${sign}${capture(match, 2)}:${capture(match, 3)}` };
+}
+function formatZonedDateTime(match) {
+    const year = Number(capture(match, 1));
+    const month = Number(capture(match, 2));
+    const day = Number(capture(match, 3));
+    const hour = Number(capture(match, 4));
+    const minute = Number(capture(match, 5));
+    const second = Number(capture(match, 6));
+    if (!validCalendarDate(year, month, day) || !validTime(hour, minute, second)) {
+        return undefined;
+    }
+    const zone = parseZoneOffset(capture(match, 7));
+    if (!zone) {
+        return undefined;
+    }
+    return `${capture(match, 1)}-${capture(match, 2)}-${capture(match, 3)}T${capture(match, 4)}:${capture(match, 5)}:${capture(match, 6)}${zone.canonical}`;
+}
+function formatLocalDateOnly(match) {
+    const year = Number(capture(match, 1));
+    const month = Number(capture(match, 2));
+    const day = Number(capture(match, 3));
+    const hour = Number(capture(match, 4));
+    const minute = Number(capture(match, 5));
+    const second = Number(capture(match, 6));
+    if (!validCalendarDate(year, month, day) || !validTime(hour, minute, second)) {
+        return undefined;
+    }
+    // A local date-time without an explicit UTC offset never establishes a
+    // reliable instant: reduce it to the calendar date it unambiguously names
+    // instead of inventing an offset.
+    return `${capture(match, 1)}-${capture(match, 2)}-${capture(match, 3)}`;
+}
+function formatNamedMonthDate(monthName, dayValue, yearValue) {
+    const month = monthNumber(monthName);
+    if (!month) {
+        return undefined;
+    }
+    const day = Number(dayValue);
+    const year = Number(yearValue);
+    if (!validCalendarDate(year, month, day)) {
+        return undefined;
+    }
+    const pad = (value) => String(value).padStart(2, "0");
+    return `${yearValue}-${pad(month)}-${pad(day)}`;
+}
+function digitLength(value) {
+    return (value < 0n ? -value : value).toString().length;
+}
+/**
+ * Infers the epoch unit (seconds, milliseconds, microseconds, or
+ * nanoseconds) from the number of significant digits and returns the
+ * equivalent millisecond count. Values with too few digits to plausibly be a
+ * modern timestamp, or too many digits to be any of the four supported
+ * units, are rejected so arbitrary numeric identifiers are not treated as
+ * dates.
+ */
+function epochToMilliseconds(value) {
+    const digits = digitLength(value);
+    if (digits < 6) {
+        return undefined;
+    }
+    if (digits <= 10) {
+        return value * 1000n;
+    }
+    if (digits <= 13) {
+        return value;
+    }
+    if (digits <= 16) {
+        return floorDivide(value, 1000n);
+    }
+    if (digits <= 19) {
+        return floorDivide(value, 1000000n);
+    }
+    return undefined;
+}
+function floorDivide(value, divisor) {
+    const quotient = value / divisor;
+    return value < 0n && value % divisor !== 0n ? quotient - 1n : quotient;
+}
+function formatEpochMilliseconds(ms) {
+    if (ms < -MAX_SAFE_DATE_MS || ms > MAX_SAFE_DATE_MS) {
+        return undefined;
+    }
+    const date = new Date(Number(ms));
+    if (Number.isNaN(date.getTime()) || date.getUTCFullYear() < 0 || date.getUTCFullYear() > 9999) {
+        return undefined;
+    }
+    return date.toISOString().replace(/\.\d{3}Z$/u, "Z");
+}
+function normalizeEpochBigInt(value) {
+    const ms = epochToMilliseconds(value);
+    return ms === undefined ? undefined : formatEpochMilliseconds(ms);
+}
+function normalizeEpochNumber(value) {
+    if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
+        return undefined;
+    }
+    // Route through the string path so a compact YYYYMMDD-shaped integer (e.g.
+    // 20260831) is recognized as a date before being treated as an epoch, the
+    // same as an equivalent numeric string.
+    return normalizeSourceDateString(String(value));
+}
+function normalizeEpochString(trimmed) {
+    const unsigned = trimmed.startsWith("+") ? trimmed.slice(1) : trimmed;
+    try {
+        return normalizeEpochBigInt(BigInt(unsigned));
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeSourceDateString(trimmed) {
+    const compactMatch = COMPACT_DATE.exec(trimmed);
+    if (compactMatch) {
+        if (validCalendarDate(Number(compactMatch[1]), Number(compactMatch[2]), Number(compactMatch[3]))) {
+            return `${compactMatch[1]}-${compactMatch[2]}-${compactMatch[3]}`;
+        }
+        return undefined;
+    }
+    if (INTEGER_STRING.test(trimmed)) {
+        return normalizeEpochString(trimmed);
+    }
+    const dateMatch = RFC3339_DATE.exec(trimmed);
+    if (dateMatch) {
+        return validCalendarDate(Number(dateMatch[1]), Number(dateMatch[2]), Number(dateMatch[3]))
+            ? trimmed
+            : undefined;
+    }
+    const zonedMatch = ZONED_DATE_TIME.exec(trimmed);
+    if (zonedMatch) {
+        return formatZonedDateTime(zonedMatch);
+    }
+    const localMatch = LOCAL_DATE_TIME.exec(trimmed);
+    if (localMatch) {
+        return formatLocalDateOnly(localMatch);
+    }
+    const monthDayYear = MONTH_DAY_YEAR.exec(trimmed);
+    if (monthDayYear) {
+        return formatNamedMonthDate(capture(monthDayYear, 1), capture(monthDayYear, 2), capture(monthDayYear, 3));
+    }
+    const dayMonthYear = DAY_MONTH_YEAR.exec(trimmed);
+    if (dayMonthYear) {
+        return formatNamedMonthDate(capture(dayMonthYear, 2), capture(dayMonthYear, 1), capture(dayMonthYear, 3));
+    }
+    return undefined;
+}
+/**
+ * Normalizes heterogeneous source-article date metadata (published/updated)
+ * into exactly one of:
+ * - `YYYY-MM-DD`, when only a calendar date is reliably known, or
+ * - an RFC 3339 date-time with an explicit `Z` or numeric offset and
+ *   second-level precision.
+ *
+ * Accepts strings, finite integer numbers (interpreted as Unix epoch
+ * seconds/milliseconds/microseconds/nanoseconds based on magnitude), JSON-LD
+ * value objects (`{"@value": ..., "@type": ...}`), and arrays of candidates
+ * (the first value that normalizes successfully is used). Unsupported or
+ * ambiguous shapes return `undefined` instead of throwing or guessing.
+ */
+export function normalizeSourceDate(value) {
+    const candidates = [value];
+    const seen = new Set();
+    while (candidates.length > 0) {
+        const candidate = candidates.pop();
+        if (candidate === undefined || candidate === null) {
+            continue;
+        }
+        if (Array.isArray(candidate)) {
+            if (seen.has(candidate)) {
+                continue;
+            }
+            seen.add(candidate);
+            for (let index = candidate.length - 1; index >= 0; index -= 1) {
+                candidates.push(candidate[index]);
+            }
+            continue;
+        }
+        if (typeof candidate === "number") {
+            const normalized = normalizeEpochNumber(candidate);
+            if (normalized !== undefined) {
+                return normalized;
+            }
+            continue;
+        }
+        if (typeof candidate === "string") {
+            const trimmed = candidate.trim();
+            const normalized = trimmed ? normalizeSourceDateString(trimmed) : undefined;
+            if (normalized !== undefined) {
+                return normalized;
+            }
+            continue;
+        }
+        if (typeof candidate === "object") {
+            if (seen.has(candidate)) {
+                continue;
+            }
+            seen.add(candidate);
+            const record = candidate;
+            if ("@value" in record) {
+                candidates.push(record["@value"]);
+            }
+        }
+    }
+    return undefined;
+}
+export function isRfc3339DateTime(value) {
+    return value !== undefined && parseRfc3339(value) !== undefined;
+}
+export function httpDateToRfc3339(value, now = new Date()) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const timestamp = parseHttpDate(trimmed, now);
+    if (timestamp === undefined) {
+        return undefined;
+    }
+    return new Date(timestamp).toISOString().replace(".000Z", "Z");
+}
+export function rfc3339ToHttpDate(value) {
+    if (!value) {
+        return undefined;
+    }
+    const timestamp = parseRfc3339(value);
+    return timestamp === undefined ? undefined : new Date(timestamp).toUTCString();
+}

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export type MdhqErrorCode = "INVALID_URL" | "INVALID_HEADER" | "UNSUPPORTED_SCHEME" | "UNSUPPORTED_CONTENT_TYPE" | "RESPONSE_TOO_LARGE" | "TOO_MANY_REDIRECTS" | "FETCH_FAILED" | "CONVERSION_FAILED" | "CONFIG_ERROR" | "PATH_COLLISION" | "PATH_TOO_LONG" | "STORAGE_ERROR";
+export declare class MdhqError extends Error {
+    readonly code: MdhqErrorCode;
+    readonly cause?: unknown;
+    constructor(code: MdhqErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,10 @@
+export class MdhqError extends Error {
+    code;
+    cause;
+    constructor(code, message, options) {
+        super(message);
+        this.name = "MdhqError";
+        this.code = code;
+        this.cause = options?.cause;
+    }
+}

package/dist/frontmatter/frontmatter.d.ts

@@ -0,0 +1,40 @@
+import type { MdhqConfig } from "../config/config.js";
+import type { PageMetadata } from "../types.js";
+export interface FrontmatterOptions {
+    metadata: PageMetadata;
+    sourceUrl: string;
+    requestedUrl: string;
+    created: Date | string;
+    modified: Date;
+    contentDigest: string;
+    etag?: string;
+    lastModified?: string;
+    vary?: string[];
+    image?: string;
+    imageSource?: string;
+    config?: MdhqConfig["frontmatter"];
+}
+interface ControlledFrontmatterOptions {
+    fields: Record<string, unknown>;
+    sourceUrl: string;
+    requestedUrl: string;
+    created: Date | string;
+    modified: Date;
+    contentDigest: string;
+    etag?: string;
+    lastModified?: string;
+    vary?: string[];
+    config?: MdhqConfig["frontmatter"];
+}
+export declare function buildFrontmatter(options: FrontmatterOptions): Record<string, unknown>;
+export declare function refreshFrontmatter(existing: Record<string, unknown>, options: Omit<ControlledFrontmatterOptions, "fields">): Record<string, unknown>;
+export declare function normalizeMarkdownBody(markdown: string): string;
+export declare function markdownContentDigest(markdown: string): string;
+export declare function serializeDocument(frontmatter: Record<string, unknown>, markdown: string): string;
+export interface ParsedDocument {
+    frontmatter: Record<string, unknown>;
+    markdown: string;
+}
+export declare function parseDocument(document: string): ParsedDocument | undefined;
+export declare function parseDocumentFrontmatter(document: string): Record<string, unknown> | undefined;
+export {};

package/dist/frontmatter/frontmatter.js

@@ -0,0 +1,114 @@
+import { createHash } from "node:crypto";
+import { parse, stringify } from "yaml";
+import { formatLocalRfc3339 } from "../date.js";
+function applyControlledFields(options) {
+    const fields = { ...options.fields };
+    delete fields.type;
+    for (const key of options.config?.exclude ?? []) {
+        delete fields[key];
+    }
+    for (const [key, value] of Object.entries(options.config?.values ?? {})) {
+        fields[key] = value;
+    }
+    fields.source = options.sourceUrl;
+    if (options.requestedUrl !== options.sourceUrl) {
+        fields.requested_url = options.requestedUrl;
+    }
+    else {
+        delete fields.requested_url;
+    }
+    fields.created =
+        typeof options.created === "string"
+            ? options.created
+            : formatLocalRfc3339(options.created);
+    fields.modified = formatLocalRfc3339(options.modified);
+    fields.content_digest = options.contentDigest;
+    if (options.etag) {
+        fields.etag = options.etag;
+    }
+    else {
+        delete fields.etag;
+    }
+    if (options.lastModified) {
+        fields.last_modified = options.lastModified;
+    }
+    else {
+        delete fields.last_modified;
+    }
+    if (options.vary) {
+        fields.vary = options.vary;
+    }
+    else {
+        delete fields.vary;
+    }
+    return fields;
+}
+export function buildFrontmatter(options) {
+    const fields = {};
+    const metadataFields = [
+        ["title", options.metadata.title],
+        ["description", options.metadata.description],
+        ["author", options.metadata.author],
+        ["published", options.metadata.published],
+        ["updated", options.metadata.updated],
+        ["site", options.metadata.site],
+        ["domain", options.metadata.domain],
+        ["language", options.metadata.language],
+        ["word_count", options.metadata.wordCount]
+    ];
+    for (const [key, value] of metadataFields) {
+        if (value !== undefined && value !== "") {
+            fields[key] = value;
+        }
+    }
+    if (options.image) {
+        fields.image = options.image;
+    }
+    else if (options.metadata.image) {
+        fields.image = options.metadata.image;
+    }
+    if (options.imageSource) {
+        fields.image_source = options.imageSource;
+    }
+    return applyControlledFields({ ...options, fields });
+}
+export function refreshFrontmatter(existing, options) {
+    return applyControlledFields({ ...options, fields: existing });
+}
+export function normalizeMarkdownBody(markdown) {
+    const normalized = markdown.replace(/\r\n?/gu, "\n").trimEnd();
+    return normalized ? `${normalized}\n` : "";
+}
+export function markdownContentDigest(markdown) {
+    return `sha256:${createHash("sha256").update(normalizeMarkdownBody(markdown), "utf8").digest("hex")}`;
+}
+export function serializeDocument(frontmatter, markdown) {
+    return `---\n${stringify(frontmatter, { lineWidth: 0 }).trimEnd()}\n---\n\n${normalizeMarkdownBody(markdown)}`;
+}
+export function parseDocument(document) {
+    const normalized = document.replace(/\r\n?/gu, "\n");
+    if (!normalized.startsWith("---\n")) {
+        return undefined;
+    }
+    const end = normalized.indexOf("\n---\n", 4);
+    if (end < 0) {
+        return undefined;
+    }
+    try {
+        const value = parse(normalized.slice(4, end));
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return undefined;
+        }
+        const afterFrontmatter = normalized.slice(end + 5);
+        return {
+            frontmatter: value,
+            markdown: normalizeMarkdownBody(afterFrontmatter.startsWith("\n") ? afterFrontmatter.slice(1) : afterFrontmatter)
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function parseDocumentFrontmatter(document) {
+    return parseDocument(document)?.frontmatter;
+}

package/dist/get-page.d.ts

@@ -0,0 +1,2 @@
+import type { GetPageOptions, GetPageResult } from "./types.js";
+export declare function getPage(options: GetPageOptions): Promise<GetPageResult>;