pagespeed-quest 0.3.2 → 0.3.3

package/build/adhoc.d.ts

@@ -0,0 +1,2 @@
+export declare function recording(): Promise<void>;
+export declare function playback(): Promise<void>;

package/build/adhoc.js

@@ -0,0 +1,31 @@
+import Fsp from 'fs/promises';
+import { Dependency } from './dependency.js';
+import { InventoryRepository } from './inventory.js';
+import { execLighthouse } from './lighthouse.js';
+import { withPlaybackProxy } from './playback.js';
+import { withRecordingProxy } from './recording.js';
+const dependency = new Dependency();
+export async function recording() {
+    const sampleUrl = 'https://www.gov-online.go.jp/';
+    // const sampleUrl = 'https://blog.ideamans.com/'
+    await Fsp.mkdir('./tmp', { recursive: true });
+    const inventoryRepository = new InventoryRepository('./tmp', dependency);
+    await withRecordingProxy({
+        inventoryRepository,
+    }, dependency, async (proxy) => {
+        proxy.entryUrl = sampleUrl;
+        await execLighthouse({ url: sampleUrl, proxyPort: proxy.port, headless: false }, dependency);
+    });
+}
+export async function playback() {
+    const inventoryRepository = new InventoryRepository('./tmp', dependency);
+    await withPlaybackProxy({
+        inventoryRepository,
+    }, dependency, async (proxy) => {
+        if (!proxy.entryUrl)
+            throw new Error('proxy.entryUrl is empty');
+        await execLighthouse({ url: proxy.entryUrl, proxyPort: proxy.port, headless: false }, dependency);
+    });
+}
+playback();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRob2MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYWRob2MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxHQUFHLE1BQU0sYUFBYSxDQUFBO0FBRTdCLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUM1QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQTtBQUNwRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDaEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFBO0FBQ2pELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBRW5ELE1BQU0sVUFBVSxHQUFHLElBQUksVUFBVSxFQUFFLENBQUE7QUFFbkMsTUFBTSxDQUFDLEtBQUssVUFBVSxTQUFTO0lBQzdCLE1BQU0sU0FBUyxHQUFHLCtCQUErQixDQUFBO0lBQ2pELGlEQUFpRDtJQUVqRCxNQUFNLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUE7SUFDN0MsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLG1CQUFtQixDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQTtJQUN4RSxNQUFNLGtCQUFrQixDQUN0QjtRQUNFLG1CQUFtQjtLQUNwQixFQUNELFVBQVUsRUFDVixLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUU7UUFDZCxLQUFLLENBQUMsUUFBUSxHQUFHLFNBQVMsQ0FBQTtRQUMxQixNQUFNLGNBQWMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLEtBQUssQ0FBQyxJQUFJLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxFQUFFLFVBQVUsQ0FBQyxDQUFBO0lBQzlGLENBQUMsQ0FDRixDQUFBO0FBQ0gsQ0FBQztBQUVELE1BQU0sQ0FBQyxLQUFLLFVBQVUsUUFBUTtJQUM1QixNQUFNLG1CQUFtQixHQUFHLElBQUksbUJBQW1CLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFBO0lBQ3hFLE1BQU0saUJBQWlCLENBQ3JCO1FBQ0UsbUJBQW1CO0tBQ3BCLEVBQ0QsVUFBVSxFQUNWLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRTtRQUNkLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQTtRQUMvRCxNQUFNLGNBQWMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxLQUFLLENBQUMsUUFBUSxFQUFFLFNBQVMsRUFBRSxLQUFLLENBQUMsSUFBSSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsRUFBRSxVQUFVLENBQUMsQ0FBQTtJQUNuRyxDQUFDLENBQ0YsQ0FBQTtBQUNILENBQUM7QUFFRCxRQUFRLEVBQUUsQ0FBQSJ9

package/build/command.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/command.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import Watch from 'node-watch';
+import { Dependency } from './dependency.js';
+import { execLighthouse } from './lighthouse.js';
+import { execLoadshow } from './loadshow.js';
+import { InventoryRepository, withPlaybackProxy, withRecordingProxy } from './index.js';
+const dependency = new Dependency();
+const main = new Command();
+main.option('-i, --inventory <dir>', 'Inventory directory', './inventory');
+function registerLighthouseCommands(main) {
+    const lighthouse = main.command('lighthouse');
+    lighthouse.description('Run Lighthouse (performance category) via a proxy');
+    lighthouse.option('-a, --artifacts <dir>', 'Artifacts directory', './artifacts');
+    lighthouse.option('-q, --quiet', 'Run headless', false);
+    const recording = lighthouse.command('recording');
+    recording.description('Record contents by lighthouse');
+    recording.option('-d, --device <mobile|desktop>', 'Device type', 'mobile');
+    recording.argument('<url>', 'Url to measure performance');
+    recording.action(async (url) => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const deviceType = recording.opts().device || 'mobile';
+        const artifactsDir = lighthouse.opts().artifacts || './artifacts';
+        const quiet = !!lighthouse.opts().quiet;
+        await withRecordingProxy({
+            entryUrl: url,
+            deviceType,
+            inventoryRepository,
+        }, dependency, async (proxy) => {
+            await execLighthouse({ url, proxyPort: proxy.port, deviceType, noThrottling: true, view: false, artifactsDir, headless: quiet }, dependency);
+            dependency.logger?.info('Lighthouse completed. Saving inventory...');
+        });
+    });
+    const playback = lighthouse.command('playback');
+    playback.description('Playback contents for lighthouse');
+    playback.action(async () => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const artifactsDir = lighthouse.opts().artifacts || './artifacts';
+        const quiet = !!lighthouse.opts().quiet;
+        await withPlaybackProxy({
+            inventoryRepository,
+        }, dependency, async (proxy) => {
+            await execLighthouse({
+                url: proxy.entryUrl,
+                proxyPort: proxy.port,
+                deviceType: proxy.deviceType,
+                view: !quiet,
+                artifactsDir,
+                headless: quiet,
+            }, dependency);
+            dependency.logger?.info('Lighthouse completed');
+        });
+    });
+}
+function registerLoadshowCommands(main) {
+    const loadshow = main.command('loadshow');
+    loadshow.description('Run loadshow via a proxy');
+    loadshow.option('-a, --artifacts <dir>', 'Artifacts directory', './artifacts');
+    const recording = loadshow.command('recording');
+    recording.description('Record contents by loadshow');
+    recording.option('-d, --device <mobile|desktop>', 'Device type', 'mobile');
+    recording.argument('<url>', 'Url to measure performance');
+    recording.action(async (url) => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const deviceType = recording.opts().device || 'mobile';
+        const artifactsDir = loadshow.opts().artifacts || './artifacts';
+        await withRecordingProxy({ entryUrl: url, deviceType, inventoryRepository }, dependency, async (proxy) => {
+            await execLoadshow({ url, proxyPort: proxy.port, deviceType, artifactsDir }, dependency);
+            dependency.logger?.info('Loadshow completed. Saving inventory...');
+        });
+    });
+    const playback = loadshow.command('playback');
+    playback.description('Playback contents for loadshow');
+    playback.option('-l, --lighthouse', 'Loadshow with lighthouse throttling');
+    playback.action(async () => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const lighthouse = playback.opts().lighthouse;
+        const artifactsDir = loadshow.opts().artifacts || './artifacts';
+        await withPlaybackProxy({
+            inventoryRepository,
+        }, dependency, async (proxy) => {
+            await execLoadshow({
+                url: proxy.entryUrl,
+                proxyPort: proxy.port,
+                deviceType: proxy.deviceType,
+                syncLighthouseSpec: lighthouse,
+                artifactsDir,
+            }, dependency);
+            dependency.logger?.info('Loadshow completed');
+        });
+    });
+}
+function registerProxyCommands(main) {
+    const proxy = main.command('proxy');
+    proxy.option('-p, --port <number>', 'Proxy port', '8080');
+    proxy.action(async () => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const proxyOptions = {
+            inventoryRepository,
+            port: Number(proxy.opts().port || '8080'),
+        };
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            await withPlaybackProxy(proxyOptions, dependency, async () => {
+                const watcher = Watch(inventoryRepository.dirPath, { recursive: true });
+                return new Promise((ok) => {
+                    watcher.on('change', () => {
+                        watcher.close();
+                        dependency.logger?.info('Inventory changed. Restarting proxy...');
+                        ok();
+                    });
+                });
+            });
+        }
+    });
+}
+registerLighthouseCommands(main);
+registerLoadshowCommands(main);
+registerProxyCommands(main);
+main.parse(process.argv);
+//# sourceMappingURL=data:application/json;base64,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

package/build/dependency.d.ts

@@ -0,0 +1,9 @@
+import Pino from 'pino';
+import { DependencyInterface } from './types.js';
+export declare class Dependency implements DependencyInterface {
+    logger?: Pino.Logger;
+    constructor();
+    mkdirp(dirPath: string): Promise<void>;
+    executeLighthouse(args: string[]): Promise<void>;
+    executeLoadshow(args: string[]): Promise<void>;
+}

package/build/dependency.js

@@ -0,0 +1,31 @@
+import Fsp from 'fs/promises';
+import { execa } from 'execa';
+import Pino from 'pino';
+export class Dependency {
+    logger;
+    constructor() {
+        this.logger = Pino({
+            level: process.env.LOG_LEVEL || 'info',
+            transport: {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                    ignore: 'pid,hostname',
+                    hideObject: !['', '0', 'false', 'no'].includes(process.env.LOG_OBJECTS?.toLowerCase()),
+                },
+            },
+        });
+    }
+    async mkdirp(dirPath) {
+        await Fsp.mkdir(dirPath, { recursive: true });
+    }
+    async executeLighthouse(args) {
+        const lighthousePath = process.env.LIGHTHOUSE_PATH || './node_modules/.bin/lighthouse';
+        await execa(lighthousePath, args, { stdout: 'inherit', stderr: 'inherit' });
+    }
+    async executeLoadshow(args) {
+        const loadshowPath = process.env.LOADSHOW_PATH || './node_modules/.bin/loadshow';
+        await execa(loadshowPath, args, { stdout: 'inherit', stderr: 'inherit' });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwZW5kZW5jeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kZXBlbmRlbmN5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sR0FBRyxNQUFNLGFBQWEsQ0FBQTtBQUU3QixPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sT0FBTyxDQUFBO0FBQzdCLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQTtBQUl2QixNQUFNLE9BQU8sVUFBVTtJQUNyQixNQUFNLENBQWM7SUFFcEI7UUFDRSxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQztZQUNqQixLQUFLLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxTQUFTLElBQUksTUFBTTtZQUN0QyxTQUFTLEVBQUU7Z0JBQ1QsTUFBTSxFQUFFLGFBQWE7Z0JBQ3JCLE9BQU8sRUFBRTtvQkFDUCxRQUFRLEVBQUUsSUFBSTtvQkFDZCxNQUFNLEVBQUUsY0FBYztvQkFDdEIsVUFBVSxFQUFFLENBQUMsQ0FBQyxFQUFFLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLEVBQUUsV0FBVyxFQUFFLENBQUM7aUJBQ3ZGO2FBQ0Y7U0FDRixDQUFDLENBQUE7SUFDSixDQUFDO0lBRUQsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFlO1FBQzFCLE1BQU0sR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtJQUMvQyxDQUFDO0lBRUQsS0FBSyxDQUFDLGlCQUFpQixDQUFDLElBQWM7UUFDcEMsTUFBTSxjQUFjLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLElBQUksZ0NBQWdDLENBQUE7UUFDdEYsTUFBTSxLQUFLLENBQUMsY0FBYyxFQUFFLElBQUksRUFBRSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUE7SUFDN0UsQ0FBQztJQUVELEtBQUssQ0FBQyxlQUFlLENBQUMsSUFBYztRQUNsQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsSUFBSSw4QkFBOEIsQ0FBQTtRQUNoRixNQUFNLEtBQUssQ0FBQyxZQUFZLEVBQUUsSUFBSSxFQUFFLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLENBQUMsQ0FBQTtJQUMzRSxDQUFDO0NBQ0YifQ==

package/build/encoding.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import Zlib from 'zlib';
+export type ContentEncodingType = 'gzip' | 'compress' | 'deflate' | 'br' | 'identity';
+export interface ContentEncodingPair {
+    compress: typeof Zlib.gzip;
+    decompress: typeof Zlib.gunzip;
+}
+export declare const ContentEncodingMap: Map<ContentEncodingType, ContentEncodingPair>;
+export declare function compress(type: ContentEncodingType, buffer: Buffer): Promise<Buffer>;
+export declare function decompress(type: ContentEncodingType, buffer: Buffer): Promise<Buffer>;

package/build/encoding.js

@@ -0,0 +1,43 @@
+import Zlib from 'zlib';
+export const ContentEncodingMap = new Map();
+ContentEncodingMap.set('gzip', {
+    compress: Zlib.gzip,
+    decompress: Zlib.gunzip,
+});
+ContentEncodingMap.set('compress', {
+    compress: Zlib.gzip,
+    decompress: Zlib.gunzip,
+});
+ContentEncodingMap.set('deflate', {
+    compress: Zlib.deflate,
+    decompress: Zlib.inflate,
+});
+ContentEncodingMap.set('br', {
+    compress: Zlib.brotliCompress,
+    decompress: Zlib.brotliDecompress,
+});
+export async function compress(type, buffer) {
+    const pair = ContentEncodingMap.get(type);
+    if (!pair)
+        return Buffer.from(buffer);
+    return new Promise((resolve, reject) => {
+        pair.compress(buffer, (err, result) => {
+            if (err)
+                return reject(err);
+            resolve(result);
+        });
+    });
+}
+export async function decompress(type, buffer) {
+    const pair = ContentEncodingMap.get(type);
+    if (!pair)
+        return Buffer.from(buffer);
+    return new Promise((resolve, reject) => {
+        pair.decompress(buffer, (err, result) => {
+            if (err)
+                return reject(err);
+            resolve(result);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/formatting.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export declare function ensureUtf8String(buffer: Buffer, charset: string): string;
+export declare function isText(mimeType: string): boolean;
+export interface BeautifyResult {
+    content: Buffer;
+    charset?: string;
+}
+export declare function convertEditableText(content: Buffer, contentTypeMime: string, contentTypeCharset?: string): Promise<Buffer>;

package/build/formatting.js

@@ -0,0 +1,55 @@
+import IconvLite from 'iconv-lite';
+import Prettier from 'prettier';
+const PrettierDefaultOptions = { printWidth: 120 };
+export function ensureUtf8String(buffer, charset) {
+    if (charset.match(/utf-?8/i) || charset.match(/ascii/i))
+        return buffer.toString('utf8');
+    const converted = IconvLite.decode(buffer, charset);
+    return converted;
+}
+function isHtml(mimeType) {
+    if (!mimeType)
+        return false;
+    return mimeType === 'text/html';
+}
+function isCss(mimeType) {
+    if (!mimeType)
+        return false;
+    return mimeType === 'text/css';
+}
+function isJs(mimeType) {
+    if (!mimeType)
+        return false;
+    return (mimeType === 'text/javascript' || mimeType === 'application/javascript' || mimeType === 'application/x-javascript');
+}
+export function isText(mimeType) {
+    return isHtml(mimeType) || isCss(mimeType) || isJs(mimeType);
+}
+export async function convertEditableText(content, contentTypeMime, contentTypeCharset) {
+    const charset = contentTypeCharset || 'utf-8';
+    if (isHtml(contentTypeMime)) {
+        const utf8 = ensureUtf8String(content, charset);
+        const withoutCharsetMeta = utf8.replace(/<meta charset="[^"]*">/, '');
+        const withoutScriptCharsetAttr = withoutCharsetMeta.replace(/<script(?:.*)>/gi, (scriptTag) => {
+            return scriptTag.replace(/\s*charset\s*=\s*(?:"[^"]*"|'[^']*'|[^ ]+)/i, '');
+        });
+        // TODO: consider charset attribute in link[rel=stylesheet]
+        const html = await Prettier.format(withoutScriptCharsetAttr, { ...PrettierDefaultOptions, parser: 'html' });
+        return html;
+    }
+    else if (isCss(contentTypeMime)) {
+        const utf8 = ensureUtf8String(content, charset);
+        const withoutCharsetDirective = utf8.replace(/@charset "[^"]*";/, '');
+        const css = await Prettier.format(withoutCharsetDirective, { ...PrettierDefaultOptions, parser: 'css' });
+        return css;
+    }
+    else if (isJs(contentTypeMime)) {
+        const utf8 = ensureUtf8String(content, charset);
+        const js = await Prettier.format(utf8, { ...PrettierDefaultOptions, parser: 'babel' });
+        return js;
+    }
+    else {
+        throw new Error(`${contentTypeMime} is not supported text content type`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/http.d.ts

@@ -0,0 +1,26 @@
+export type HttpHeaders = {
+    [key: string]: string;
+};
+/**
+ * Remove IgnoreParams from URL
+ * Default: ts (timestamp) assumed different for each request
+ * @param url
+ * @returns
+ */
+export declare function normalizeUrl(url: string | URL): URL;
+/**
+ * Convert URL to content file path
+ * For example:
+ * https://example.com/foo/bar.html?hoge=123 -> example.com/foo/bar~hoge=123.html
+ * - Add directory index (index.html) if URL ends with slash
+ * - Shorten too long basename with short hash
+ * - Ignore dynamic params for example: ts=123
+ * @param url
+ * @returns
+ */
+export declare function requestContentFilePath(method: string, url: string | URL): string;
+export declare function parseContentTypeHeader(contentType: string): {
+    mime: string;
+    charset: string;
+};
+export declare function stringifyContentTypeHeader(mime?: string, charset?: string, original?: string): string;

package/build/http.js

@@ -0,0 +1,96 @@
+import Crypto from 'crypto';
+import Path from 'path';
+const DirectoryIndex = 'index.html';
+const BasenameMaxLength = 196;
+const HashLength = 8;
+const IgnoreParams = process.env.IGNORE_PARAMS || 'ts';
+const IgnoreParamsRegex = IgnoreParams.split(/\s*,\s*/).map((p) => new RegExp(`(?<=[?&]${p}=)[^&]*`, 'g'));
+/**
+ * Remove IgnoreParams from URL
+ * Default: ts (timestamp) assumed different for each request
+ * @param url
+ * @returns
+ */
+export function normalizeUrl(url) {
+    const urlObj = typeof url === 'string' ? new URL(url) : url;
+    // Remove dynamic params
+    if (urlObj.search !== '') {
+        urlObj.search = IgnoreParamsRegex.reduce((search, re) => {
+            return search.replace(re, '');
+        }, urlObj.search);
+    }
+    return urlObj;
+}
+/**
+ * Convert URL to content file path
+ * For example:
+ * https://example.com/foo/bar.html?hoge=123 -> example.com/foo/bar~hoge=123.html
+ * - Add directory index (index.html) if URL ends with slash
+ * - Shorten too long basename with short hash
+ * - Ignore dynamic params for example: ts=123
+ * @param url
+ * @returns
+ */
+export function requestContentFilePath(method, url) {
+    const urlObj = normalizeUrl(url);
+    const protocol = urlObj.protocol.replace(/:/g, '');
+    const host = urlObj.host.replace(/:/g, '~');
+    // Directory Index (index.html)
+    let pathname = urlObj.pathname;
+    if (pathname.endsWith('/')) {
+        pathname += DirectoryIndex;
+    }
+    else {
+        const ext = Path.extname(pathname);
+        if (ext === '') {
+            pathname = Path.join(pathname, DirectoryIndex);
+        }
+    }
+    const dir = Path.dirname(pathname);
+    const ext = Path.extname(pathname);
+    const base = Path.basename(pathname, ext);
+    let filename = base;
+    // Search params
+    if (urlObj.search !== '') {
+        // Remove dynamic params
+        const search = IgnoreParamsRegex.reduce((search, re) => {
+            return search.replace(re, '');
+        }, urlObj.search);
+        filename = [filename, search.slice(1)].join('~');
+    }
+    // Shorten too long basename
+    if (filename.length > BasenameMaxLength) {
+        const trunk = filename.slice(0, BasenameMaxLength);
+        const hash = Crypto.createHash('sha1');
+        hash.update(filename);
+        const digest = hash.digest('hex').slice(0, HashLength);
+        filename = [trunk, digest].join('_');
+    }
+    // Extension
+    filename += ext;
+    // Content file relative path
+    const relPath = Path.join(dir, filename);
+    return Path.join(method, protocol, host, relPath);
+}
+export function parseContentTypeHeader(contentType) {
+    const [mime, ...params] = contentType.split(/;/).map((s) => s.trim());
+    const charsetParam = params.find((p) => p.startsWith('charset='));
+    return {
+        mime,
+        charset: charsetParam ? charsetParam.slice('charset='.length) : undefined,
+    };
+}
+export function stringifyContentTypeHeader(mime, charset, original) {
+    const params = original ? original.split(/;/).map((s) => s.trim()) : [];
+    if (mime)
+        params[0] = mime;
+    if (charset) {
+        const charsetParamIndex = params.findIndex((p) => p.startsWith('charset='));
+        if (charsetParamIndex >= 0)
+            params.splice(charsetParamIndex, 1, `charset=${charset}`);
+        else
+            params.splice(1, 0, `charset=${charset}`);
+    }
+    return params.join('; ');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9odHRwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTSxNQUFNLFFBQVEsQ0FBQTtBQUMzQixPQUFPLElBQUksTUFBTSxNQUFNLENBQUE7QUFFdkIsTUFBTSxjQUFjLEdBQUcsWUFBWSxDQUFBO0FBQ25DLE1BQU0saUJBQWlCLEdBQUcsR0FBRyxDQUFBO0FBQzdCLE1BQU0sVUFBVSxHQUFHLENBQUMsQ0FBQTtBQUNwQixNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsSUFBSSxJQUFJLENBQUE7QUFDdEQsTUFBTSxpQkFBaUIsR0FBRyxZQUFZLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxNQUFNLENBQUMsV0FBVyxDQUFDLFNBQVMsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFBO0FBSTFHOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxHQUFpQjtJQUM1QyxNQUFNLE1BQU0sR0FBRyxPQUFPLEdBQUcsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLElBQUksR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUE7SUFFM0Qsd0JBQXdCO0lBQ3hCLElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxFQUFFLEVBQUU7UUFDeEIsTUFBTSxDQUFDLE1BQU0sR0FBRyxpQkFBaUIsQ0FBQyxNQUFNLENBQVMsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEVBQUU7WUFDOUQsT0FBTyxNQUFNLENBQUMsT0FBTyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQTtRQUMvQixDQUFDLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0tBQ2xCO0lBRUQsT0FBTyxNQUFNLENBQUE7QUFDZixDQUFDO0FBRUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLHNCQUFzQixDQUFDLE1BQWMsRUFBRSxHQUFpQjtJQUN0RSxNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsR0FBRyxDQUFDLENBQUE7SUFFaEMsTUFBTSxRQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFBO0lBQ2xELE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQTtJQUUzQywrQkFBK0I7SUFDL0IsSUFBSSxRQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQTtJQUM5QixJQUFJLFFBQVEsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7UUFDMUIsUUFBUSxJQUFJLGNBQWMsQ0FBQTtLQUMzQjtTQUFNO1FBQ0wsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUNsQyxJQUFJLEdBQUcsS0FBSyxFQUFFLEVBQUU7WUFDZCxRQUFRLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsY0FBYyxDQUFDLENBQUE7U0FDL0M7S0FDRjtJQUVELE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUE7SUFDbEMsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUNsQyxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQTtJQUV6QyxJQUFJLFFBQVEsR0FBRyxJQUFJLENBQUE7SUFFbkIsZ0JBQWdCO0lBQ2hCLElBQUksTUFBTSxDQUFDLE1BQU0sS0FBSyxFQUFFLEVBQUU7UUFDeEIsd0JBQXdCO1FBQ3hCLE1BQU0sTUFBTSxHQUFHLGlCQUFpQixDQUFDLE1BQU0sQ0FBUyxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRTtZQUM3RCxPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQy9CLENBQUMsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUE7UUFDakIsUUFBUSxHQUFHLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUE7S0FDakQ7SUFFRCw0QkFBNEI7SUFDNUIsSUFBSSxRQUFRLENBQUMsTUFBTSxHQUFHLGlCQUFpQixFQUFFO1FBQ3ZDLE1BQU0sS0FBSyxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLGlCQUFpQixDQUFDLENBQUE7UUFDbEQsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUN0QyxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFBO1FBQ3JCLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxVQUFVLENBQUMsQ0FBQTtRQUN0RCxRQUFRLEdBQUcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFBO0tBQ3JDO0lBRUQsWUFBWTtJQUNaLFFBQVEsSUFBSSxHQUFHLENBQUE7SUFFZiw2QkFBNkI7SUFDN0IsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsUUFBUSxDQUFDLENBQUE7SUFFeEMsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFBO0FBQ25ELENBQUM7QUFFRCxNQUFNLFVBQVUsc0JBQXNCLENBQUMsV0FBbUI7SUFDeEQsTUFBTSxDQUFDLElBQUksRUFBRSxHQUFHLE1BQU0sQ0FBQyxHQUFHLFdBQVcsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQTtJQUNyRSxNQUFNLFlBQVksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUE7SUFDakUsT0FBTztRQUNMLElBQUk7UUFDSixPQUFPLEVBQUUsWUFBWSxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUztLQUMxRSxDQUFBO0FBQ0gsQ0FBQztBQUVELE1BQU0sVUFBVSwwQkFBMEIsQ0FBQyxJQUFhLEVBQUUsT0FBZ0IsRUFBRSxRQUFpQjtJQUMzRixNQUFNLE1BQU0sR0FBYSxRQUFRLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFBO0lBQ2pGLElBQUksSUFBSTtRQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUE7SUFDMUIsSUFBSSxPQUFPLEVBQUU7UUFDWCxNQUFNLGlCQUFpQixHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQTtRQUMzRSxJQUFJLGlCQUFpQixJQUFJLENBQUM7WUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLGlCQUFpQixFQUFFLENBQUMsRUFBRSxXQUFXLE9BQU8sRUFBRSxDQUFDLENBQUE7O1lBQ2hGLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxXQUFXLE9BQU8sRUFBRSxDQUFDLENBQUE7S0FDL0M7SUFDRCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7QUFDMUIsQ0FBQyJ9

package/build/index.d.ts

@@ -0,0 +1,8 @@
+export * from './encoding.js';
+export * from './formatting.js';
+export * from './http.js';
+export * from './inventory.js';
+export * from './playback.js';
+export * from './proxy.js';
+export * from './recording.js';
+export * from './throttling.js';

package/build/index.js

@@ -0,0 +1,9 @@
+export * from './encoding.js';
+export * from './formatting.js';
+export * from './http.js';
+export * from './inventory.js';
+export * from './playback.js';
+export * from './proxy.js';
+export * from './recording.js';
+export * from './throttling.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyxpQkFBaUIsQ0FBQTtBQUMvQixjQUFjLFdBQVcsQ0FBQTtBQUN6QixjQUFjLGdCQUFnQixDQUFBO0FBQzlCLGNBQWMsZUFBZSxDQUFBO0FBQzdCLGNBQWMsWUFBWSxDQUFBO0FBQzFCLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxpQkFBaUIsQ0FBQSJ9

package/build/inventory.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { ContentEncodingType } from './encoding.js';
+import { HttpHeaders } from './http.js';
+import { DependencyInterface, DeviceType } from './types.js';
+export interface Resource {
+    method: string;
+    url: string;
+    ttfbMs: number;
+    mbps?: number;
+    statusCode?: number;
+    errorMessage?: string;
+    rawHeaders?: HttpHeaders;
+    contentEncoding?: ContentEncodingType;
+    contentTypeMime?: string;
+    contentTypeCharset?: string;
+    contentFilePath?: string;
+    contentUtf8?: string;
+    contentBase64?: string;
+    minify?: boolean;
+}
+export interface Transaction {
+    method: string;
+    url: string;
+    ttfbMs: number;
+    statusCode?: number;
+    errorMessage?: string;
+    rawHeaders?: HttpHeaders;
+    content?: Buffer;
+    durationMs?: number;
+}
+export interface Inventory {
+    entryUrl?: string;
+    deviceType?: DeviceType;
+    resources: Resource[];
+}
+type InventoryRepositoryDependency = Pick<DependencyInterface, 'logger'>;
+export declare class InventoryRepository {
+    dirPath: string;
+    dependency: InventoryRepositoryDependency;
+    constructor(dirPath?: string, dependency?: InventoryRepositoryDependency);
+    saveInventory(inventory: Inventory): Promise<void>;
+    loadInventory(): Promise<Inventory>;
+    saveTransactions(transactions: Transaction[]): Promise<Resource[]>;
+    loadTransactions(resources: Resource[]): Promise<Transaction[]>;
+}
+export {};