@songmu/mdhq 0.0.2

package/dist/markdown/transform.js

@@ -0,0 +1,129 @@
+import { gfmFromMarkdown, gfmToMarkdown } from "mdast-util-gfm";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { gfm } from "micromark-extension-gfm";
+function walk(node, visitor) {
+    visitor(node);
+    const children = node.children;
+    if (Array.isArray(children)) {
+        for (const child of children) {
+            walk(child, visitor);
+        }
+    }
+}
+function absoluteUrl(value, baseUrl) {
+    if (value.startsWith("#")) {
+        return value;
+    }
+    try {
+        return new URL(value, baseUrl).href;
+    }
+    catch {
+        return value;
+    }
+}
+function parseMarkdown(markdown) {
+    return fromMarkdown(markdown, {
+        extensions: [gfm()],
+        mdastExtensions: [gfmFromMarkdown()]
+    });
+}
+function serializeMarkdown(tree) {
+    return toMarkdown(tree, { extensions: [gfmToMarkdown()] }).trimEnd();
+}
+function isDownloadableImage(value) {
+    try {
+        const protocol = new URL(value).protocol;
+        return protocol === "http:" || protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+export function transformMarkdown(markdown, baseUrl) {
+    const tree = parseMarkdown(markdown);
+    const definitions = new Map();
+    walk(tree, (node) => {
+        if (node.type === "definition") {
+            if (!definitions.has(node.identifier)) {
+                definitions.set(node.identifier, node);
+            }
+        }
+    });
+    const imageUrls = [];
+    const seenImages = new Set();
+    const addImage = (url) => {
+        if (isDownloadableImage(url) && !seenImages.has(url)) {
+            seenImages.add(url);
+            imageUrls.push(url);
+        }
+    };
+    walk(tree, (node) => {
+        if (node.type === "link") {
+            const link = node;
+            link.url = absoluteUrl(link.url, baseUrl);
+        }
+        else if (node.type === "image") {
+            const image = node;
+            image.url = absoluteUrl(image.url, baseUrl);
+            addImage(image.url);
+        }
+        else if (node.type === "linkReference" || node.type === "imageReference") {
+            const definition = definitions.get(node.identifier);
+            if (definition) {
+                definition.url = absoluteUrl(definition.url, baseUrl);
+                if (node.type === "imageReference") {
+                    addImage(definition.url);
+                }
+            }
+        }
+    });
+    return { markdown: serializeMarkdown(tree), imageUrls };
+}
+export function rewriteImageUrls(markdown, replacements) {
+    const tree = parseMarkdown(markdown);
+    const definitions = new Map();
+    const linkReferences = new Set();
+    walk(tree, (node) => {
+        if (node.type === "definition") {
+            if (!definitions.has(node.identifier)) {
+                definitions.set(node.identifier, node);
+            }
+        }
+        else if (node.type === "linkReference") {
+            linkReferences.add(node.identifier);
+        }
+        else if (node.type === "image") {
+            const image = node;
+            image.url = replacements.get(image.url) ?? image.url;
+        }
+    });
+    const rewriteReferences = (parent) => {
+        parent.children = parent.children.map((node) => {
+            if (node.type === "imageReference") {
+                const imageReference = node;
+                const definition = definitions.get(imageReference.identifier);
+                const replacement = definition
+                    ? replacements.get(definition.url)
+                    : undefined;
+                if (definition && replacement) {
+                    if (linkReferences.has(imageReference.identifier)) {
+                        return {
+                            type: "image",
+                            url: replacement,
+                            alt: imageReference.alt,
+                            title: definition.title
+                        };
+                    }
+                    definition.url = replacement;
+                }
+            }
+            if ("children" in node && Array.isArray(node.children)) {
+                rewriteReferences(node);
+            }
+            return node;
+        });
+    };
+    rewriteReferences(tree);
+    return serializeMarkdown(tree);
+}

package/dist/path/storage-path.d.ts

@@ -0,0 +1,7 @@
+export declare function sanitizePathSegment(rawSegment: string): string;
+export interface StoragePathOptions {
+    root: string;
+    url: string | URL;
+    entryQueryKey?: string;
+}
+export declare function storagePathForUrl(options: StoragePathOptions): string;

package/dist/path/storage-path.js

@@ -0,0 +1,110 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { MdhqError } from "../errors.js";
+import { createUrlIdentity, parseHttpUrl } from "../url/identity.js";
+import { decodeUrlPathSegment, storageBasename } from "../url/pathname.js";
+const INVALID_CHARACTERS = /[\/\\:*?"<>|\u0000-\u001f\u007f]/u;
+const WINDOWS_DEVICES = /^(con|prn|aux|nul|com(?:[1-9]|[¹²³])|lpt(?:[1-9]|[¹²³]))(?:\.|$)/iu;
+const MAX_SEGMENT_BYTES = 240;
+const MAX_ABSOLUTE_PATH_LENGTH = process.platform === "win32" ? 240 : 1000;
+function md5(value) {
+    return createHash("md5").update(value).digest("hex");
+}
+function absolutePathLength(value) {
+    return process.platform === "win32" ? value.length : Buffer.byteLength(value);
+}
+function ensureWithinRoot(root, target) {
+    const relative = path.relative(root, target);
+    if (relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative)) {
+        throw new MdhqError("PATH_COLLISION", `Storage path escapes its root: ${target}`);
+    }
+    return target;
+}
+function encodeCharacter(character) {
+    return [...Buffer.from(character)].map((byte) => `%${byte.toString(16).toUpperCase().padStart(2, "0")}`).join("");
+}
+export function sanitizePathSegment(rawSegment) {
+    const normalized = decodeUrlPathSegment(rawSegment);
+    if (normalized === "." || normalized === ".." || WINDOWS_DEVICES.test(normalized)) {
+        return [...normalized].map(encodeCharacter).join("");
+    }
+    const characters = [...normalized];
+    return characters
+        .map((character, index) => {
+        const trailingUnsafe = index === characters.length - 1 && (character === " " || character === ".");
+        return INVALID_CHARACTERS.test(character) || character === "%" || trailingUnsafe
+            ? encodeCharacter(character)
+            : character;
+    })
+        .join("");
+}
+function fitSegment(rawSegment, suffix = "") {
+    const sanitized = sanitizePathSegment(rawSegment);
+    return Buffer.byteLength(`${sanitized}${suffix}`) <= MAX_SEGMENT_BYTES
+        ? sanitized
+        : md5(decodeUrlPathSegment(rawSegment));
+}
+function markdownFilename(rawSegment) {
+    const safe = fitSegment(encodeURIComponent(storageBasename(rawSegment)), ".md");
+    return `${safe}.md`;
+}
+function hostDirectory(url) {
+    const identity = createUrlIdentity(url);
+    const ipv6 = identity.host.match(/^\[([^\]]+)\](?::(\d+))?$/u);
+    const host = ipv6
+        ? `[${ipv6[1]?.replaceAll(":", "_")}]${ipv6[2] ? `_${ipv6[2]}` : ""}`
+        : identity.host.replaceAll(":", "_");
+    const safeHost = fitSegment(encodeURIComponent(host));
+    if (safeHost.toLowerCase() === "_assets") {
+        throw new MdhqError("PATH_COLLISION", "The normalized host conflicts with _assets");
+    }
+    return safeHost;
+}
+export function storagePathForUrl(options) {
+    const url = parseHttpUrl(options.url);
+    const identity = createUrlIdentity(url, options.entryQueryKey);
+    const rawSegments = url.pathname.split("/").filter(Boolean);
+    const directories = rawSegments.slice(0, -1).map((segment) => fitSegment(segment));
+    let filename;
+    if (identity.entryValue !== undefined) {
+        const pageSegment = rawSegments.at(-1) ?? "index";
+        directories.push(fitSegment(pageSegment));
+        filename = `${fitSegment(encodeURIComponent(identity.entryValue), ".md")}.md`;
+    }
+    else if (rawSegments.length === 0) {
+        filename = "index.md";
+    }
+    else {
+        filename = markdownFilename(rawSegments.at(-1) ?? "index");
+    }
+    const allSegments = [hostDirectory(url), ...directories, filename];
+    const resolvedRoot = path.resolve(options.root);
+    let result = path.resolve(resolvedRoot, ...allSegments);
+    if (absolutePathLength(result) <= MAX_ABSOLUTE_PATH_LENGTH) {
+        return ensureWithinRoot(resolvedRoot, result);
+    }
+    const candidates = allSegments
+        .map((segment, index) => ({
+        index,
+        length: absolutePathLength(segment),
+        replacementLength: segment.endsWith(".md") ? 35 : 32
+    }))
+        .filter((candidate) => candidate.length > candidate.replacementLength)
+        .sort((a, b) => b.length - a.length);
+    for (const candidate of candidates) {
+        const current = allSegments[candidate.index];
+        if (!current) {
+            continue;
+        }
+        allSegments[candidate.index] = current.endsWith(".md")
+            ? `${md5(current.slice(0, -3))}.md`
+            : md5(current);
+        result = path.resolve(resolvedRoot, ...allSegments);
+        if (absolutePathLength(result) <= MAX_ABSOLUTE_PATH_LENGTH) {
+            return ensureWithinRoot(resolvedRoot, result);
+        }
+    }
+    throw new MdhqError("PATH_TOO_LONG", `Storage path is too long for ${url.href}: ${result}`);
+}

package/dist/storage/atomic.d.ts

@@ -0,0 +1,8 @@
+type FileContent = string | Uint8Array;
+export declare function withDestinationLock<T>(targetPath: string, operation: () => Promise<T>, root?: string): Promise<T>;
+export declare function publishFileExclusive(targetPath: string, content: FileContent, root?: string): Promise<boolean>;
+export declare function replaceFileAtomic(targetPath: string, content: FileContent, options?: {
+    root?: string;
+    beforeCommit?: () => Promise<void>;
+}): Promise<void>;
+export {};

package/dist/storage/atomic.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { link, mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { lock } from "proper-lockfile";
+import { assertSafeDestination } from "./path-safety.js";
+const LOCK_STALE_MS = 300_000;
+const LOCK_RETRY_INTERVAL_MS = 100;
+const LOCK_WAIT_MS = 60_000;
+function temporaryPath(targetPath) {
+    return path.join(path.dirname(targetPath), `.${path.basename(targetPath)}.${randomUUID()}.tmp`);
+}
+export async function withDestinationLock(targetPath, operation, root) {
+    const lockPath = `${targetPath}.lock`;
+    if (root) {
+        await assertSafeDestination(root, lockPath);
+    }
+    await mkdir(path.dirname(lockPath), { recursive: true });
+    const release = await lock(targetPath, {
+        realpath: false,
+        lockfilePath: lockPath,
+        stale: LOCK_STALE_MS,
+        update: LOCK_STALE_MS / 3,
+        retries: {
+            retries: LOCK_WAIT_MS / LOCK_RETRY_INTERVAL_MS,
+            factor: 1,
+            minTimeout: LOCK_RETRY_INTERVAL_MS,
+            maxTimeout: LOCK_RETRY_INTERVAL_MS,
+            randomize: false
+        }
+    });
+    try {
+        return await operation();
+    }
+    finally {
+        await release();
+    }
+}
+export async function publishFileExclusive(targetPath, content, root) {
+    if (root) {
+        await assertSafeDestination(root, targetPath);
+    }
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    if (root) {
+        await assertSafeDestination(root, targetPath);
+    }
+    const tempPath = temporaryPath(targetPath);
+    try {
+        await writeFile(tempPath, content, { flag: "wx" });
+        try {
+            await link(tempPath, targetPath);
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    finally {
+        await unlink(tempPath).catch(() => undefined);
+    }
+}
+export async function replaceFileAtomic(targetPath, content, options = {}) {
+    if (options.root) {
+        await assertSafeDestination(options.root, targetPath);
+    }
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    if (options.root) {
+        await assertSafeDestination(options.root, targetPath);
+    }
+    const tempPath = temporaryPath(targetPath);
+    try {
+        await writeFile(tempPath, content, { flag: "wx" });
+        await options.beforeCommit?.();
+        if (options.root) {
+            await assertSafeDestination(options.root, targetPath);
+        }
+        await rename(tempPath, targetPath);
+    }
+    finally {
+        await unlink(tempPath).catch(() => undefined);
+    }
+}

package/dist/storage/path-safety.d.ts

@@ -0,0 +1 @@
+export declare function assertSafeDestination(root: string, target: string): Promise<void>;

package/dist/storage/path-safety.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import { lstat, realpath } from "node:fs/promises";
+import { MdhqError } from "../errors.js";
+function isWithin(root, target) {
+    const relative = path.relative(root, target);
+    return (relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+export async function assertSafeDestination(root, target) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedTarget = path.resolve(target);
+    if (!isWithin(resolvedRoot, resolvedTarget)) {
+        throw new MdhqError("PATH_COLLISION", `Storage path escapes its root: ${resolvedTarget}`);
+    }
+    let rootMetadata;
+    try {
+        rootMetadata = await lstat(resolvedRoot);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    if (!rootMetadata.isDirectory() && !rootMetadata.isSymbolicLink()) {
+        throw new MdhqError("PATH_COLLISION", `Storage root is not a directory: ${resolvedRoot}`);
+    }
+    const realRoot = await realpath(resolvedRoot);
+    const relative = path.relative(resolvedRoot, path.dirname(resolvedTarget));
+    let current = resolvedRoot;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        let metadata;
+        try {
+            metadata = await lstat(current);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+        if (metadata.isSymbolicLink()) {
+            throw new MdhqError("PATH_COLLISION", `Storage directory is a symbolic link: ${current}`);
+        }
+        if (!metadata.isDirectory()) {
+            throw new MdhqError("PATH_COLLISION", `Storage path component is not a directory: ${current}`);
+        }
+        const realCurrent = await realpath(current);
+        if (!isWithin(realRoot, realCurrent) && realCurrent !== realRoot) {
+            throw new MdhqError("PATH_COLLISION", `Storage directory escapes its root: ${current}`);
+        }
+    }
+}

package/dist/storage/save.d.ts

@@ -0,0 +1,23 @@
+export interface SaveDocumentOptions {
+    path: string;
+    content: string;
+    sourceUrl: string;
+    update: boolean;
+    expectedContent?: string | null;
+    entryQueryKey?: string;
+    root?: string;
+}
+export interface ExistingDocument {
+    content: string;
+    sourceUrl: string;
+    frontmatter: Record<string, unknown>;
+    markdown: string;
+    contentDigest: string;
+    created?: string;
+    etag?: string;
+    lastModified?: string;
+    vary?: string[];
+}
+export declare function readExistingDocument(filePath: string): Promise<ExistingDocument | undefined>;
+export declare function inspectDestination(filePath: string, sourceUrl: string, entryQueryKey?: string, root?: string): Promise<ExistingDocument | undefined>;
+export declare function saveDocument(options: SaveDocumentOptions): Promise<"saved" | "updated" | "skipped" | "conflicted">;

package/dist/storage/save.js

@@ -0,0 +1,118 @@
+import path from "node:path";
+import { mkdir, readFile } from "node:fs/promises";
+import { MdhqError } from "../errors.js";
+import { markdownContentDigest, parseDocument } from "../frontmatter/frontmatter.js";
+import { sameUrlIdentity } from "../url/identity.js";
+import { publishFileExclusive, replaceFileAtomic, withDestinationLock } from "./atomic.js";
+import { assertSafeDestination } from "./path-safety.js";
+export async function readExistingDocument(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw new MdhqError("STORAGE_ERROR", `Failed to read ${filePath}`, { cause: error });
+    }
+    const parsed = parseDocument(content);
+    if (!parsed || typeof parsed.frontmatter.source !== "string") {
+        throw new MdhqError("PATH_COLLISION", `Existing file does not contain a valid source URL: ${filePath}`);
+    }
+    const frontmatter = parsed.frontmatter;
+    const sourceUrl = frontmatter.source;
+    return {
+        content,
+        sourceUrl,
+        frontmatter,
+        markdown: parsed.markdown,
+        contentDigest: markdownContentDigest(parsed.markdown),
+        ...(typeof frontmatter.created === "string" ? { created: frontmatter.created } : {}),
+        ...(typeof frontmatter.etag === "string" ? { etag: frontmatter.etag } : {}),
+        ...(typeof frontmatter.last_modified === "string"
+            ? { lastModified: frontmatter.last_modified }
+            : {}),
+        ...(Array.isArray(frontmatter.vary) &&
+            frontmatter.vary.every((value) => typeof value === "string")
+            ? { vary: frontmatter.vary }
+            : {})
+    };
+}
+function assertSameIdentity(existing, sourceUrl, entryQueryKey, filePath) {
+    let matches = false;
+    try {
+        matches =
+            existing !== undefined &&
+                sameUrlIdentity(existing.sourceUrl, sourceUrl, entryQueryKey);
+    }
+    catch {
+        matches = false;
+    }
+    if (!matches) {
+        throw new MdhqError("PATH_COLLISION", `Storage path is already used by another URL: ${filePath}`);
+    }
+}
+export async function inspectDestination(filePath, sourceUrl, entryQueryKey, root) {
+    if (root) {
+        await assertSafeDestination(root, filePath);
+    }
+    const existing = await readExistingDocument(filePath);
+    if (existing) {
+        assertSameIdentity(existing, sourceUrl, entryQueryKey, filePath);
+    }
+    return existing;
+}
+export async function saveDocument(options) {
+    if (options.root) {
+        await assertSafeDestination(options.root, options.path);
+    }
+    await mkdir(path.dirname(options.path), { recursive: true });
+    try {
+        return await withDestinationLock(options.path, async () => {
+            const existing = await readExistingDocument(options.path);
+            const hasExpectation = options.expectedContent !== undefined;
+            if (hasExpectation &&
+                (existing?.content ?? null) !== options.expectedContent) {
+                return "conflicted";
+            }
+            if (existing) {
+                assertSameIdentity(existing, options.sourceUrl, options.entryQueryKey, options.path);
+                if (!options.update) {
+                    return "skipped";
+                }
+            }
+            if (existing) {
+                await replaceFileAtomic(options.path, options.content, {
+                    ...(options.root ? { root: options.root } : {}),
+                    beforeCommit: async () => {
+                        const current = await readExistingDocument(options.path);
+                        assertSameIdentity(current, options.sourceUrl, options.entryQueryKey, options.path);
+                        if (hasExpectation &&
+                            current?.content !== options.expectedContent) {
+                            throw new DestinationChangedError();
+                        }
+                    }
+                });
+                return "updated";
+            }
+            if (await publishFileExclusive(options.path, options.content, options.root)) {
+                return "saved";
+            }
+            const current = await readExistingDocument(options.path);
+            assertSameIdentity(current, options.sourceUrl, options.entryQueryKey, options.path);
+            return hasExpectation ? "conflicted" : "skipped";
+        }, options.root);
+    }
+    catch (error) {
+        if (error instanceof DestinationChangedError) {
+            return "conflicted";
+        }
+        if (error instanceof MdhqError) {
+            throw error;
+        }
+        throw new MdhqError("STORAGE_ERROR", `Failed to ${options.update ? "update" : "write"} ${options.path}`, { cause: error });
+    }
+}
+class DestinationChangedError extends Error {
+}

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+import type { DefuddleOptions } from "defuddle/node";
+export interface MdhqWarning {
+    code: string;
+    message: string;
+    url?: string;
+}
+export interface HeaderValue {
+    name: string;
+    value: string;
+}
+export interface ConvertHtmlOptions {
+    html: string;
+    url: string | URL;
+    defuddle?: Omit<DefuddleOptions, "markdown" | "url">;
+}
+export interface ConvertedPage {
+    markdown: string;
+    metadata: PageMetadata;
+}
+export interface PageMetadata {
+    title?: string;
+    description?: string;
+    author?: string;
+    published?: string;
+    updated?: string;
+    site?: string;
+    domain?: string;
+    language?: string;
+    image?: string;
+    favicon?: string;
+    wordCount?: number;
+}
+export interface GetPageOptions {
+    url: string | URL;
+    root?: string;
+    configPath?: string;
+    assets?: boolean;
+    update?: boolean;
+    headers?: HeaderValue[];
+    userAgent?: string;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    maxRedirects?: number;
+    useAsync?: boolean;
+    now?: () => Date;
+    onWarning?: (warning: MdhqWarning) => void;
+}
+export interface AssetResult {
+    sourceUrl: string;
+    finalUrl?: string;
+    path?: string;
+    status: "saved" | "reused" | "failed";
+    error?: string;
+}
+export interface GetPageResult {
+    requestedUrl: string;
+    sourceUrl: string;
+    path: string;
+    status: "saved" | "updated" | "unchanged" | "skipped";
+    assets: AssetResult[];
+    warnings: MdhqWarning[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/url/identity.d.ts

@@ -0,0 +1,12 @@
+export interface UrlIdentity {
+    host: string;
+    pathname: string;
+    entryKey?: string;
+    entryValue?: string;
+}
+export declare function parseHttpUrl(input: string | URL): URL;
+export declare function normalizeHost(url: URL): string;
+export declare function createUrlIdentity(input: string | URL, entryQueryKey?: string): UrlIdentity;
+export declare function serializeUrlIdentity(identity: UrlIdentity): string;
+export declare function sameUrlIdentity(left: string | URL, right: string | URL, entryQueryKey?: string): boolean;
+export declare function sameHttpTarget(left: string | URL, right: string | URL): boolean;

package/dist/url/identity.js

@@ -0,0 +1,54 @@
+import { domainToASCII } from "node:url";
+import { MdhqError } from "../errors.js";
+import { canonicalPathname } from "./pathname.js";
+export function parseHttpUrl(input) {
+    let url;
+    try {
+        url = input instanceof URL ? new URL(input.href) : new URL(input);
+    }
+    catch (error) {
+        throw new MdhqError("INVALID_URL", `Invalid URL: ${String(input)}`, { cause: error });
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new MdhqError("UNSUPPORTED_SCHEME", `Unsupported URL scheme: ${url.protocol}`);
+    }
+    return url;
+}
+export function normalizeHost(url) {
+    const rawHostname = url.hostname.toLowerCase();
+    const hostname = domainToASCII(/^\.+$/u.test(rawHostname) ? rawHostname : rawHostname.replace(/\.+$/u, ""));
+    const standardPort = (url.protocol === "http:" && url.port === "80") ||
+        (url.protocol === "https:" && url.port === "443");
+    return url.port && !standardPort ? `${hostname}:${url.port}` : hostname;
+}
+export function createUrlIdentity(input, entryQueryKey) {
+    const url = parseHttpUrl(input);
+    const entryValue = entryQueryKey ? url.searchParams.get(entryQueryKey) : null;
+    const hasEntryValue = entryValue !== null && entryValue !== "";
+    const identity = {
+        host: normalizeHost(url),
+        pathname: canonicalPathname(url.pathname || "/", hasEntryValue)
+    };
+    if (entryQueryKey && hasEntryValue) {
+        identity.entryKey = entryQueryKey;
+        identity.entryValue = entryValue.normalize("NFC");
+    }
+    return identity;
+}
+export function serializeUrlIdentity(identity) {
+    const entry = identity.entryKey && identity.entryValue
+        ? `?${encodeURIComponent(identity.entryKey)}=${encodeURIComponent(identity.entryValue)}`
+        : "";
+    return `//${identity.host}${identity.pathname}${entry}`;
+}
+export function sameUrlIdentity(left, right, entryQueryKey) {
+    return (serializeUrlIdentity(createUrlIdentity(left, entryQueryKey)) ===
+        serializeUrlIdentity(createUrlIdentity(right, entryQueryKey)));
+}
+export function sameHttpTarget(left, right) {
+    const leftUrl = parseHttpUrl(left);
+    const rightUrl = parseHttpUrl(right);
+    leftUrl.hash = "";
+    rightUrl.hash = "";
+    return leftUrl.href === rightUrl.href;
+}

package/dist/url/pathname.d.ts

@@ -0,0 +1,4 @@
+export declare const HTML_EXTENSIONS: Set<string>;
+export declare function decodeUrlPathSegment(segment: string): string;
+export declare function storageBasename(segment: string): string;
+export declare function canonicalPathname(pathname: string, hasEntryValue?: boolean): string;