hx-cdn-forge 2.0.0

package/dist/index.d.mts

@@ -0,0 +1,328 @@
+import React$1 from 'react';
+
+type CDNRegion = 'china' | 'asia' | 'global';
+type LatencyStatus = 'idle' | 'testing' | 'success' | 'failed';
+interface CDNNode {
+    id: string;
+    name: string;
+    baseUrl: string;
+    region: CDNRegion;
+    buildUrl: (ctx: GitHubContext, filePath: string) => string;
+    maxFileSize: number;
+    supportsRange: boolean;
+    testPath?: string;
+    description?: string;
+    enabled?: boolean;
+}
+interface GitHubContext {
+    user: string;
+    repo: string;
+    ref: string;
+}
+interface ForgeConfig {
+    github: GitHubContext;
+    nodes?: CDNNode[];
+    defaultNodeId?: string;
+    autoTest?: boolean;
+    testTimeout?: number;
+    testRetries?: number;
+    splitThreshold?: number;
+    mappingPrefix?: string;
+    splitStoragePath?: string;
+    storageKey?: string;
+    maxConcurrency?: number;
+    chunkTimeout?: number;
+    maxRetries?: number;
+    enableWorkStealing?: boolean;
+    turboMode?: boolean;
+    turboConcurrentCDNs?: number;
+}
+interface SplitInfo {
+    originalName: string;
+    totalSize: number;
+    mimeType: string;
+    chunks: SplitChunkInfo[];
+    createdAt: string;
+    chunkSize: number;
+}
+interface SplitChunkInfo {
+    fileName: string;
+    index: number;
+    size: number;
+    sha256: string;
+}
+interface SplitCache {
+    sourcePath: string;
+    sourceHash: string;
+    sourceSize: number;
+    generatedAt: string;
+}
+interface LatencyResult {
+    nodeId: string;
+    latency: number;
+    success: boolean;
+    timestamp: number;
+    error?: string;
+}
+interface CDNNodeWithLatency extends CDNNode {
+    latency?: number;
+    latencyStatus?: LatencyStatus;
+}
+interface DownloadProgress {
+    loaded: number;
+    total: number;
+    percentage: number;
+    speed: number;
+    eta: number;
+    completedChunks: number;
+    totalChunks: number;
+}
+interface DownloadResult {
+    blob: Blob;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    totalSize: number;
+    totalTime: number;
+    contentType: string;
+    usedSplitMode: boolean;
+    usedParallelMode: boolean;
+    nodeContributions: Map<string, {
+        bytes: number;
+        chunks: number;
+        avgSpeed: number;
+    }>;
+}
+interface CDNProviderProps {
+    config: ForgeConfig;
+    children: React.ReactNode;
+    onInitialized?: (currentNode: CDNNode | null) => void;
+    onNodeChange?: (node: CDNNode) => void;
+}
+interface CDNContextValue {
+    config: ForgeConfig;
+    currentNode: CDNNode | null;
+    nodes: CDNNodeWithLatency[];
+    isTesting: boolean;
+    isInitialized: boolean;
+    latencyResults: Map<string, LatencyResult>;
+    selectNode: (nodeId: string) => void;
+    testAllNodes: () => Promise<LatencyResult[]>;
+    reqByCDN: (filePath: string, onProgress?: (p: DownloadProgress) => void) => Promise<DownloadResult>;
+    buildUrl: (filePath: string) => string;
+    getSortedNodes: () => CDNNodeWithLatency[];
+}
+interface CDNNodeSelectorProps {
+    className?: string;
+    style?: React.CSSProperties;
+    showLatency?: boolean;
+    showRegion?: boolean;
+    title?: string;
+    showRefreshButton?: boolean;
+    disabled?: boolean;
+    compact?: boolean;
+    onChange?: (node: CDNNode) => void;
+    onTestComplete?: (results: LatencyResult[]) => void;
+    renderTrigger?: (props: {
+        currentNode: CDNNode | null;
+        isOpen: boolean;
+        isTesting: boolean;
+    }) => React.ReactNode;
+    renderNode?: (props: NodeRenderProps) => React.ReactNode;
+    renderEmpty?: () => React.ReactNode;
+    renderLoading?: () => React.ReactNode;
+}
+interface NodeRenderProps {
+    node: CDNNodeWithLatency;
+    isSelected: boolean;
+    isDisabled: boolean;
+    latencyText: string;
+    latencyClassName: string;
+    onSelect: () => void;
+}
+interface SplitCommandOptions {
+    source: string;
+    outputDir: string;
+    mappingPrefix: string;
+    chunkSize?: number;
+    force?: boolean;
+}
+
+declare const DEFAULTS: {
+    readonly splitThreshold: number;
+    readonly chunkSizeForSplit: number;
+    readonly testTimeout: 5000;
+    readonly testRetries: 2;
+    readonly maxConcurrency: 6;
+    readonly chunkTimeout: 30000;
+    readonly maxRetries: 3;
+    readonly enableWorkStealing: true;
+    readonly turboMode: false;
+    readonly turboConcurrentCDNs: 3;
+    readonly storageKey: "hx-cdn-forge-node";
+    readonly autoTest: true;
+};
+declare function normalizeConfig(config: ForgeConfig): Required<ForgeConfig>;
+declare function createForgeConfig(github: GitHubContext, options?: Partial<Omit<ForgeConfig, 'github'>>): ForgeConfig;
+
+declare const CDN_NODE_PRESETS: {
+    jsdelivr_main: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    jsdelivr_fastly: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    jsdelivr_testing: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    jsd_mirror: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "china";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    zstatic: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "china";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    github_raw: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+};
+declare const DEFAULT_GITHUB_CDN_NODES: CDNNode[];
+declare function createWorkerNode(domain: string): CDNNode;
+declare class CDNTester {
+    private timeout;
+    private retryCount;
+    constructor(timeout?: number, retryCount?: number);
+    testNode(node: CDNNode, testUrl?: string): Promise<LatencyResult>;
+    testAll(nodes: CDNNode[]): Promise<LatencyResult[]>;
+    testAllStreaming(nodes: CDNNode[], onResult: (r: LatencyResult) => void): Promise<LatencyResult[]>;
+    getBestNodeId(results: LatencyResult[]): string | null;
+    setTimeout(ms: number): void;
+    setRetryCount(n: number): void;
+}
+declare function getSortedNodesWithLatency(nodes: CDNNode[], results: Map<string, LatencyResult>): CDNNodeWithLatency[];
+
+declare function parseInfoYaml(text: string): SplitInfo;
+declare function serializeInfoYaml(info: SplitInfo): string;
+declare function parseCacheYaml(text: string): SplitCache;
+declare function serializeCacheYaml(cache: SplitCache): string;
+
+declare class ForgeEngine {
+    private config;
+    private tester;
+    private fetcher;
+    private currentNodeId;
+    private latencyResults;
+    private initialized;
+    private readyResolve;
+    private readyPromise;
+    private splitInfoCache;
+    constructor(config: ForgeConfig);
+    private markReady;
+    waitReady(): Promise<void>;
+    initialize(): Promise<void>;
+    initializeStreaming(onResult: (r: LatencyResult) => void, onReady?: () => void): Promise<void>;
+    getNodes(): CDNNode[];
+    getCurrentNode(): CDNNode | null;
+    selectNode(nodeId: string): CDNNode | null;
+    getSortedNodes(): CDNNodeWithLatency[];
+    getLatencyResults(): Map<string, LatencyResult>;
+    testAndSelectBest(onResult?: (r: LatencyResult) => void): Promise<LatencyResult[]>;
+    testAllNodes(): Promise<LatencyResult[]>;
+    testAllNodesStreaming(onResult: (r: LatencyResult) => void): Promise<LatencyResult[]>;
+    buildUrl(filePath: string): string;
+    reqByCDN(filePath: string, onProgress?: (p: DownloadProgress) => void): Promise<DownloadResult>;
+    private tryGetSplitInfo;
+    private downloadSplit;
+    private downloadDirect;
+    private readStreamWithProgress;
+    private mapFilePath;
+    private loadSelectedNode;
+    private saveSelectedNode;
+    getConfig(): Required<ForgeConfig>;
+    isInitialized(): boolean;
+    clearSplitInfoCache(): void;
+}
+
+interface ChunkedFetcherOptions {
+    maxConcurrency: number;
+    chunkTimeout: number;
+    maxRetries: number;
+    enableWorkStealing: boolean;
+    turboMode: boolean;
+    turboConcurrentCDNs: number;
+}
+interface ChunkedFetchResult {
+    blob: Blob;
+    totalSize: number;
+    totalTime: number;
+    nodeContributions: Map<string, {
+        bytes: number;
+        chunks: number;
+        avgSpeed: number;
+    }>;
+    usedParallelMode: boolean;
+    contentType: string;
+}
+declare class ChunkedFetcher {
+    private opts;
+    constructor(opts?: Partial<ChunkedFetcherOptions>);
+    downloadChunks(chunkUrls: string[][], chunkSizes: number[], totalSize: number, contentType: string, nodes: CDNNode[], latencyResults?: Map<string, LatencyResult>, onProgress?: (p: DownloadProgress) => void): Promise<ChunkedFetchResult>;
+    private downloadStandard;
+    private downloadTurbo;
+    private raceDownload;
+    private fetchChunk;
+    private buildResult;
+}
+
+declare function CDNProvider({ config, children, onInitialized, onNodeChange, }: CDNProviderProps): React$1.ReactElement;
+declare function useCDN(): CDNContextValue;
+declare function useCDNUrl(relativePath: string): string;
+declare function useCurrentCDNNode(): CDNNode | null;
+declare function useCDNStatus(): CDNContextValue;
+declare function useReqByCDN(): (filePath: string, onProgress?: (p: DownloadProgress) => void) => Promise<DownloadResult>;
+
+declare const REGION_LABELS: Record<string, string>;
+declare function getLatencyText(node: CDNNodeWithLatency): string;
+declare function getLatencyClassName(node: CDNNodeWithLatency): string;
+declare function CDNNodeSelector({ className, style, showLatency, showRegion, title, showRefreshButton, disabled, compact, onChange, onTestComplete, renderTrigger, renderNode, renderEmpty, renderLoading, }: CDNNodeSelectorProps): React$1.ReactElement;
+
+export { type CDNContextValue, type CDNNode, CDNNodeSelector, type CDNNodeSelectorProps, type CDNNodeWithLatency, CDNProvider, type CDNProviderProps, type CDNRegion, CDNTester, CDN_NODE_PRESETS, type ChunkedFetchResult, ChunkedFetcher, type ChunkedFetcherOptions, DEFAULTS, DEFAULT_GITHUB_CDN_NODES, type DownloadProgress, type DownloadResult, type ForgeConfig, ForgeEngine, type GitHubContext, type LatencyResult, type LatencyStatus, type NodeRenderProps, REGION_LABELS, type SplitCache, type SplitChunkInfo, type SplitCommandOptions, type SplitInfo, createForgeConfig, createWorkerNode, getLatencyClassName, getLatencyText, getSortedNodesWithLatency, normalizeConfig, parseCacheYaml, parseInfoYaml, serializeCacheYaml, serializeInfoYaml, useCDN, useCDNStatus, useCDNUrl, useCurrentCDNNode, useReqByCDN };

package/dist/index.d.ts

@@ -0,0 +1,328 @@
+import React$1 from 'react';
+
+type CDNRegion = 'china' | 'asia' | 'global';
+type LatencyStatus = 'idle' | 'testing' | 'success' | 'failed';
+interface CDNNode {
+    id: string;
+    name: string;
+    baseUrl: string;
+    region: CDNRegion;
+    buildUrl: (ctx: GitHubContext, filePath: string) => string;
+    maxFileSize: number;
+    supportsRange: boolean;
+    testPath?: string;
+    description?: string;
+    enabled?: boolean;
+}
+interface GitHubContext {
+    user: string;
+    repo: string;
+    ref: string;
+}
+interface ForgeConfig {
+    github: GitHubContext;
+    nodes?: CDNNode[];
+    defaultNodeId?: string;
+    autoTest?: boolean;
+    testTimeout?: number;
+    testRetries?: number;
+    splitThreshold?: number;
+    mappingPrefix?: string;
+    splitStoragePath?: string;
+    storageKey?: string;
+    maxConcurrency?: number;
+    chunkTimeout?: number;
+    maxRetries?: number;
+    enableWorkStealing?: boolean;
+    turboMode?: boolean;
+    turboConcurrentCDNs?: number;
+}
+interface SplitInfo {
+    originalName: string;
+    totalSize: number;
+    mimeType: string;
+    chunks: SplitChunkInfo[];
+    createdAt: string;
+    chunkSize: number;
+}
+interface SplitChunkInfo {
+    fileName: string;
+    index: number;
+    size: number;
+    sha256: string;
+}
+interface SplitCache {
+    sourcePath: string;
+    sourceHash: string;
+    sourceSize: number;
+    generatedAt: string;
+}
+interface LatencyResult {
+    nodeId: string;
+    latency: number;
+    success: boolean;
+    timestamp: number;
+    error?: string;
+}
+interface CDNNodeWithLatency extends CDNNode {
+    latency?: number;
+    latencyStatus?: LatencyStatus;
+}
+interface DownloadProgress {
+    loaded: number;
+    total: number;
+    percentage: number;
+    speed: number;
+    eta: number;
+    completedChunks: number;
+    totalChunks: number;
+}
+interface DownloadResult {
+    blob: Blob;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+    totalSize: number;
+    totalTime: number;
+    contentType: string;
+    usedSplitMode: boolean;
+    usedParallelMode: boolean;
+    nodeContributions: Map<string, {
+        bytes: number;
+        chunks: number;
+        avgSpeed: number;
+    }>;
+}
+interface CDNProviderProps {
+    config: ForgeConfig;
+    children: React.ReactNode;
+    onInitialized?: (currentNode: CDNNode | null) => void;
+    onNodeChange?: (node: CDNNode) => void;
+}
+interface CDNContextValue {
+    config: ForgeConfig;
+    currentNode: CDNNode | null;
+    nodes: CDNNodeWithLatency[];
+    isTesting: boolean;
+    isInitialized: boolean;
+    latencyResults: Map<string, LatencyResult>;
+    selectNode: (nodeId: string) => void;
+    testAllNodes: () => Promise<LatencyResult[]>;
+    reqByCDN: (filePath: string, onProgress?: (p: DownloadProgress) => void) => Promise<DownloadResult>;
+    buildUrl: (filePath: string) => string;
+    getSortedNodes: () => CDNNodeWithLatency[];
+}
+interface CDNNodeSelectorProps {
+    className?: string;
+    style?: React.CSSProperties;
+    showLatency?: boolean;
+    showRegion?: boolean;
+    title?: string;
+    showRefreshButton?: boolean;
+    disabled?: boolean;
+    compact?: boolean;
+    onChange?: (node: CDNNode) => void;
+    onTestComplete?: (results: LatencyResult[]) => void;
+    renderTrigger?: (props: {
+        currentNode: CDNNode | null;
+        isOpen: boolean;
+        isTesting: boolean;
+    }) => React.ReactNode;
+    renderNode?: (props: NodeRenderProps) => React.ReactNode;
+    renderEmpty?: () => React.ReactNode;
+    renderLoading?: () => React.ReactNode;
+}
+interface NodeRenderProps {
+    node: CDNNodeWithLatency;
+    isSelected: boolean;
+    isDisabled: boolean;
+    latencyText: string;
+    latencyClassName: string;
+    onSelect: () => void;
+}
+interface SplitCommandOptions {
+    source: string;
+    outputDir: string;
+    mappingPrefix: string;
+    chunkSize?: number;
+    force?: boolean;
+}
+
+declare const DEFAULTS: {
+    readonly splitThreshold: number;
+    readonly chunkSizeForSplit: number;
+    readonly testTimeout: 5000;
+    readonly testRetries: 2;
+    readonly maxConcurrency: 6;
+    readonly chunkTimeout: 30000;
+    readonly maxRetries: 3;
+    readonly enableWorkStealing: true;
+    readonly turboMode: false;
+    readonly turboConcurrentCDNs: 3;
+    readonly storageKey: "hx-cdn-forge-node";
+    readonly autoTest: true;
+};
+declare function normalizeConfig(config: ForgeConfig): Required<ForgeConfig>;
+declare function createForgeConfig(github: GitHubContext, options?: Partial<Omit<ForgeConfig, 'github'>>): ForgeConfig;
+
+declare const CDN_NODE_PRESETS: {
+    jsdelivr_main: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    jsdelivr_fastly: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    jsdelivr_testing: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    jsd_mirror: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "china";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    zstatic: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "china";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+    github_raw: {
+        id: string;
+        name: string;
+        baseUrl: string;
+        region: "global";
+        buildUrl: (ctx: GitHubContext, filePath: string) => string;
+        maxFileSize: number;
+        supportsRange: true;
+        description: string;
+    };
+};
+declare const DEFAULT_GITHUB_CDN_NODES: CDNNode[];
+declare function createWorkerNode(domain: string): CDNNode;
+declare class CDNTester {
+    private timeout;
+    private retryCount;
+    constructor(timeout?: number, retryCount?: number);
+    testNode(node: CDNNode, testUrl?: string): Promise<LatencyResult>;
+    testAll(nodes: CDNNode[]): Promise<LatencyResult[]>;
+    testAllStreaming(nodes: CDNNode[], onResult: (r: LatencyResult) => void): Promise<LatencyResult[]>;
+    getBestNodeId(results: LatencyResult[]): string | null;
+    setTimeout(ms: number): void;
+    setRetryCount(n: number): void;
+}
+declare function getSortedNodesWithLatency(nodes: CDNNode[], results: Map<string, LatencyResult>): CDNNodeWithLatency[];
+
+declare function parseInfoYaml(text: string): SplitInfo;
+declare function serializeInfoYaml(info: SplitInfo): string;
+declare function parseCacheYaml(text: string): SplitCache;
+declare function serializeCacheYaml(cache: SplitCache): string;
+
+declare class ForgeEngine {
+    private config;
+    private tester;
+    private fetcher;
+    private currentNodeId;
+    private latencyResults;
+    private initialized;
+    private readyResolve;
+    private readyPromise;
+    private splitInfoCache;
+    constructor(config: ForgeConfig);
+    private markReady;
+    waitReady(): Promise<void>;
+    initialize(): Promise<void>;
+    initializeStreaming(onResult: (r: LatencyResult) => void, onReady?: () => void): Promise<void>;
+    getNodes(): CDNNode[];
+    getCurrentNode(): CDNNode | null;
+    selectNode(nodeId: string): CDNNode | null;
+    getSortedNodes(): CDNNodeWithLatency[];
+    getLatencyResults(): Map<string, LatencyResult>;
+    testAndSelectBest(onResult?: (r: LatencyResult) => void): Promise<LatencyResult[]>;
+    testAllNodes(): Promise<LatencyResult[]>;
+    testAllNodesStreaming(onResult: (r: LatencyResult) => void): Promise<LatencyResult[]>;
+    buildUrl(filePath: string): string;
+    reqByCDN(filePath: string, onProgress?: (p: DownloadProgress) => void): Promise<DownloadResult>;
+    private tryGetSplitInfo;
+    private downloadSplit;
+    private downloadDirect;
+    private readStreamWithProgress;
+    private mapFilePath;
+    private loadSelectedNode;
+    private saveSelectedNode;
+    getConfig(): Required<ForgeConfig>;
+    isInitialized(): boolean;
+    clearSplitInfoCache(): void;
+}
+
+interface ChunkedFetcherOptions {
+    maxConcurrency: number;
+    chunkTimeout: number;
+    maxRetries: number;
+    enableWorkStealing: boolean;
+    turboMode: boolean;
+    turboConcurrentCDNs: number;
+}
+interface ChunkedFetchResult {
+    blob: Blob;
+    totalSize: number;
+    totalTime: number;
+    nodeContributions: Map<string, {
+        bytes: number;
+        chunks: number;
+        avgSpeed: number;
+    }>;
+    usedParallelMode: boolean;
+    contentType: string;
+}
+declare class ChunkedFetcher {
+    private opts;
+    constructor(opts?: Partial<ChunkedFetcherOptions>);
+    downloadChunks(chunkUrls: string[][], chunkSizes: number[], totalSize: number, contentType: string, nodes: CDNNode[], latencyResults?: Map<string, LatencyResult>, onProgress?: (p: DownloadProgress) => void): Promise<ChunkedFetchResult>;
+    private downloadStandard;
+    private downloadTurbo;
+    private raceDownload;
+    private fetchChunk;
+    private buildResult;
+}
+
+declare function CDNProvider({ config, children, onInitialized, onNodeChange, }: CDNProviderProps): React$1.ReactElement;
+declare function useCDN(): CDNContextValue;
+declare function useCDNUrl(relativePath: string): string;
+declare function useCurrentCDNNode(): CDNNode | null;
+declare function useCDNStatus(): CDNContextValue;
+declare function useReqByCDN(): (filePath: string, onProgress?: (p: DownloadProgress) => void) => Promise<DownloadResult>;
+
+declare const REGION_LABELS: Record<string, string>;
+declare function getLatencyText(node: CDNNodeWithLatency): string;
+declare function getLatencyClassName(node: CDNNodeWithLatency): string;
+declare function CDNNodeSelector({ className, style, showLatency, showRegion, title, showRefreshButton, disabled, compact, onChange, onTestComplete, renderTrigger, renderNode, renderEmpty, renderLoading, }: CDNNodeSelectorProps): React$1.ReactElement;
+
+export { type CDNContextValue, type CDNNode, CDNNodeSelector, type CDNNodeSelectorProps, type CDNNodeWithLatency, CDNProvider, type CDNProviderProps, type CDNRegion, CDNTester, CDN_NODE_PRESETS, type ChunkedFetchResult, ChunkedFetcher, type ChunkedFetcherOptions, DEFAULTS, DEFAULT_GITHUB_CDN_NODES, type DownloadProgress, type DownloadResult, type ForgeConfig, ForgeEngine, type GitHubContext, type LatencyResult, type LatencyStatus, type NodeRenderProps, REGION_LABELS, type SplitCache, type SplitChunkInfo, type SplitCommandOptions, type SplitInfo, createForgeConfig, createWorkerNode, getLatencyClassName, getLatencyText, getSortedNodesWithLatency, normalizeConfig, parseCacheYaml, parseInfoYaml, serializeCacheYaml, serializeInfoYaml, useCDN, useCDNStatus, useCDNUrl, useCurrentCDNNode, useReqByCDN };