@astrojs/cloudflare 0.0.0-404-fix-20231115224256

package/dist/index.js

@@ -0,0 +1,511 @@
+import { createRedirectsFromAstroRoutes } from '@astrojs/underscore-redirects';
+import { AstroError } from 'astro/errors';
+import esbuild from 'esbuild';
+import { Miniflare } from 'miniflare';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { dirname, relative, sep } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import glob from 'tiny-glob';
+import { getAdapter } from './getAdapter.js';
+import { deduplicatePatterns } from './utils/deduplicatePatterns.js';
+import { getCFObject } from './utils/getCFObject.js';
+import { prepareImageConfig } from './utils/image-config.js';
+import { getD1Bindings, getDOBindings, getEnvVars, getKVBindings, getR2Bindings, } from './utils/parser.js';
+import { prependForwardSlash } from './utils/prependForwardSlash.js';
+import { rewriteWasmImportPath } from './utils/rewriteWasmImportPath.js';
+import { wasmModuleLoader } from './utils/wasm-module-loader.js';
+const RUNTIME_WARNING = `You are using a deprecated string format for the \`runtime\` API. Please update to the current format for better support. 
+
+Example:
+Old Format: 'local'
+Current Format: { mode: 'local', persistTo: '.wrangler/state/v3' }
+
+Please refer to our runtime documentation for more details on the format. https://docs.astro.build/en/guides/integrations-guide/cloudflare/#runtime`;
+export default function createIntegration(args) {
+    let _config;
+    let _buildConfig;
+    let _mf;
+    let _entryPoints = new Map();
+    const SERVER_BUILD_FOLDER = '/$server_build/';
+    const isModeDirectory = args?.mode === 'directory';
+    const functionPerRoute = args?.functionPerRoute ?? false;
+    let runtimeMode = { mode: 'off' };
+    if (args?.runtime === 'remote') {
+        runtimeMode = { mode: 'remote' };
+    }
+    else if (args?.runtime === 'local') {
+        runtimeMode = { mode: 'local', persistTo: '.wrangler/state/v3' };
+    }
+    else if (typeof args?.runtime === 'object' &&
+        args?.runtime.mode === 'local' &&
+        args.runtime.persistTo === undefined) {
+        runtimeMode = { mode: 'local', persistTo: '.wrangler/state/v3' };
+    }
+    else if (args?.runtime) {
+        runtimeMode = args?.runtime;
+    }
+    return {
+        name: '@astrojs/cloudflare',
+        hooks: {
+            'astro:config:setup': ({ command, config, updateConfig, logger }) => {
+                updateConfig({
+                    build: {
+                        client: new URL(`.${config.base}`, config.outDir),
+                        server: new URL(`.${SERVER_BUILD_FOLDER}`, config.outDir),
+                        serverEntry: '_worker.mjs',
+                        redirects: false,
+                    },
+                    vite: {
+                        // load .wasm files as WebAssembly modules
+                        plugins: [
+                            wasmModuleLoader({
+                                disabled: !args?.wasmModuleImports,
+                                assetsDirectory: config.build.assets,
+                            }),
+                        ],
+                    },
+                    image: prepareImageConfig(args?.imageService ?? 'DEFAULT', config.image, command, logger),
+                });
+            },
+            'astro:config:done': ({ setAdapter, config, logger }) => {
+                setAdapter(getAdapter({ isModeDirectory, functionPerRoute }));
+                _config = config;
+                _buildConfig = config.build;
+                if (_config.output === 'static') {
+                    throw new AstroError('[@astrojs/cloudflare] `output: "server"` or `output: "hybrid"` is required to use this adapter. Otherwise, this adapter is not necessary to deploy a static site to Cloudflare.');
+                }
+                if (_config.base === SERVER_BUILD_FOLDER) {
+                    throw new AstroError('[@astrojs/cloudflare] `base: "${SERVER_BUILD_FOLDER}"` is not allowed. Please change your `base` config to something else.');
+                }
+                if (typeof args?.runtime === 'string') {
+                    logger.warn(RUNTIME_WARNING);
+                }
+            },
+            'astro:server:setup': ({ server }) => {
+                if (runtimeMode.mode === 'local') {
+                    const typedRuntimeMode = runtimeMode;
+                    server.middlewares.use(async function middleware(req, res, next) {
+                        try {
+                            const cf = await getCFObject(typedRuntimeMode.mode);
+                            const vars = await getEnvVars();
+                            const D1Bindings = await getD1Bindings();
+                            const R2Bindings = await getR2Bindings();
+                            const KVBindings = await getKVBindings();
+                            const DOBindings = await getDOBindings();
+                            let bindingsEnv = new Object({});
+                            // fix for the error "kj/filesystem-disk-unix.c++:1709: warning: PWD environment variable doesn't match current directory."
+                            // note: This mismatch might be primarily due to the test runner.
+                            const originalPWD = process.env.PWD;
+                            process.env.PWD = process.cwd();
+                            _mf = new Miniflare({
+                                modules: true,
+                                script: '',
+                                cache: true,
+                                cachePersist: `${typedRuntimeMode.persistTo}/cache`,
+                                cacheWarnUsage: true,
+                                d1Databases: D1Bindings,
+                                d1Persist: `${typedRuntimeMode.persistTo}/d1`,
+                                r2Buckets: R2Bindings,
+                                r2Persist: `${typedRuntimeMode.persistTo}/r2`,
+                                kvNamespaces: KVBindings,
+                                kvPersist: `${typedRuntimeMode.persistTo}/kv`,
+                                durableObjects: DOBindings,
+                                durableObjectsPersist: `${typedRuntimeMode.persistTo}/do`,
+                            });
+                            await _mf.ready;
+                            for (const D1Binding of D1Bindings) {
+                                const db = await _mf.getD1Database(D1Binding);
+                                Reflect.set(bindingsEnv, D1Binding, db);
+                            }
+                            for (const R2Binding of R2Bindings) {
+                                const bucket = await _mf.getR2Bucket(R2Binding);
+                                Reflect.set(bindingsEnv, R2Binding, bucket);
+                            }
+                            for (const KVBinding of KVBindings) {
+                                const namespace = await _mf.getKVNamespace(KVBinding);
+                                Reflect.set(bindingsEnv, KVBinding, namespace);
+                            }
+                            for (const key in DOBindings) {
+                                if (Object.prototype.hasOwnProperty.call(DOBindings, key)) {
+                                    const DO = await _mf.getDurableObjectNamespace(key);
+                                    Reflect.set(bindingsEnv, key, DO);
+                                }
+                            }
+                            const mfCache = await _mf.getCaches();
+                            process.env.PWD = originalPWD;
+                            const clientLocalsSymbol = Symbol.for('astro.locals');
+                            Reflect.set(req, clientLocalsSymbol, {
+                                runtime: {
+                                    env: {
+                                        // default binding for static assets will be dynamic once we support mocking of bindings
+                                        ASSETS: {},
+                                        // this is just a VAR for CF to change build behavior, on dev it should be 0
+                                        CF_PAGES: '0',
+                                        // will be fetched from git dynamically once we support mocking of bindings
+                                        CF_PAGES_BRANCH: 'TBA',
+                                        // will be fetched from git dynamically once we support mocking of bindings
+                                        CF_PAGES_COMMIT_SHA: 'TBA',
+                                        CF_PAGES_URL: `http://${req.headers.host}`,
+                                        ...bindingsEnv,
+                                        ...vars,
+                                    },
+                                    cf: cf,
+                                    waitUntil: (_promise) => {
+                                        return;
+                                    },
+                                    caches: mfCache,
+                                },
+                            });
+                            next();
+                        }
+                        catch {
+                            next();
+                        }
+                    });
+                }
+            },
+            'astro:server:done': async ({ logger }) => {
+                if (_mf) {
+                    logger.info('Cleaning up the Miniflare instance, and shutting down the workerd server.');
+                    await _mf.dispose();
+                }
+            },
+            'astro:build:setup': ({ vite, target }) => {
+                if (target === 'server') {
+                    vite.resolve ||= {};
+                    vite.resolve.alias ||= {};
+                    const aliases = [
+                        {
+                            find: 'react-dom/server',
+                            replacement: 'react-dom/server.browser',
+                        },
+                    ];
+                    if (Array.isArray(vite.resolve.alias)) {
+                        vite.resolve.alias = [...vite.resolve.alias, ...aliases];
+                    }
+                    else {
+                        for (const alias of aliases) {
+                            vite.resolve.alias[alias.find] = alias.replacement;
+                        }
+                    }
+                    vite.ssr ||= {};
+                    vite.ssr.target = 'webworker';
+                    // Cloudflare env is only available per request. This isn't feasible for code that access env vars
+                    // in a global way, so we shim their access as `process.env.*`. We will populate `process.env` later
+                    // in its fetch handler.
+                    vite.define = {
+                        'process.env': 'process.env',
+                        ...vite.define,
+                    };
+                }
+            },
+            'astro:build:ssr': ({ entryPoints }) => {
+                _entryPoints = entryPoints;
+            },
+            'astro:build:done': async ({ pages, routes, dir }) => {
+                const functionsUrl = new URL('functions/', _config.root);
+                const assetsUrl = new URL(_buildConfig.assets, _buildConfig.client);
+                if (isModeDirectory) {
+                    await fs.promises.mkdir(functionsUrl, { recursive: true });
+                }
+                // TODO: remove _buildConfig.split in Astro 4.0
+                if (isModeDirectory && (_buildConfig.split || functionPerRoute)) {
+                    const entryPointsURL = [..._entryPoints.values()];
+                    const entryPaths = entryPointsURL.map((entry) => fileURLToPath(entry));
+                    const outputUrl = new URL('$astro', _buildConfig.server);
+                    const outputDir = fileURLToPath(outputUrl);
+                    //
+                    // Sadly, when wasmModuleImports is enabled, this needs to build esbuild for each depth of routes/entrypoints
+                    // independently so that relative import paths to the assets are the correct depth of '../' traversals
+                    // This is inefficient, so wasmModuleImports is opt-in. This could potentially be improved in the future by
+                    // taking advantage of the esbuild "onEnd" hook to rewrite import code per entry point relative to where the final
+                    // destination of the entrypoint is
+                    const entryPathsGroupedByDepth = !args.wasmModuleImports
+                        ? [entryPaths]
+                        : entryPaths
+                            .reduce((sum, thisPath) => {
+                            const depthFromRoot = thisPath.split(sep).length;
+                            sum.set(depthFromRoot, (sum.get(depthFromRoot) || []).concat(thisPath));
+                            return sum;
+                        }, new Map())
+                            .values();
+                    for (const pathsGroup of entryPathsGroupedByDepth) {
+                        // for some reason this exports to "entry.pages" on windows instead of "pages" on unix environments.
+                        // This deduces the name of the "pages" build directory
+                        const pagesDirname = relative(fileURLToPath(_buildConfig.server), pathsGroup[0]).split(sep)[0];
+                        const absolutePagesDirname = fileURLToPath(new URL(pagesDirname, _buildConfig.server));
+                        const urlWithinFunctions = new URL(relative(absolutePagesDirname, pathsGroup[0]), functionsUrl);
+                        const relativePathToAssets = relative(dirname(fileURLToPath(urlWithinFunctions)), fileURLToPath(assetsUrl));
+                        await esbuild.build({
+                            target: 'es2022',
+                            platform: 'browser',
+                            conditions: ['workerd', 'worker', 'browser'],
+                            external: [
+                                'node:assert',
+                                'node:async_hooks',
+                                'node:buffer',
+                                'node:crypto',
+                                'node:diagnostics_channel',
+                                'node:events',
+                                'node:path',
+                                'node:process',
+                                'node:stream',
+                                'node:string_decoder',
+                                'node:util',
+                                'cloudflare:*',
+                            ],
+                            entryPoints: pathsGroup,
+                            outbase: absolutePagesDirname,
+                            outdir: outputDir,
+                            allowOverwrite: true,
+                            format: 'esm',
+                            bundle: true,
+                            minify: _config.vite?.build?.minify !== false,
+                            banner: {
+                                js: `globalThis.process = {
+									argv: [],
+									env: {},
+								};`,
+                            },
+                            logOverride: {
+                                'ignored-bare-import': 'silent',
+                            },
+                            plugins: !args?.wasmModuleImports
+                                ? []
+                                : [rewriteWasmImportPath({ relativePathToAssets })],
+                        });
+                    }
+                    const outputFiles = await glob(`**/*`, {
+                        cwd: outputDir,
+                        filesOnly: true,
+                    });
+                    // move the files into the functions folder
+                    // & make sure the file names match Cloudflare syntax for routing
+                    for (const outputFile of outputFiles) {
+                        const path = outputFile.split(sep);
+                        const finalSegments = path.map((segment) => segment
+                            .replace(/(\_)(\w+)(\_)/g, (_, __, prop) => {
+                            return `[${prop}]`;
+                        })
+                            .replace(/(\_\-\-\-)(\w+)(\_)/g, (_, __, prop) => {
+                            return `[[${prop}]]`;
+                        }));
+                        finalSegments[finalSegments.length - 1] = finalSegments[finalSegments.length - 1]
+                            .replace('entry.', '')
+                            .replace(/(.*)\.(\w+)\.(\w+)$/g, (_, fileName, __, newExt) => {
+                            return `${fileName}.${newExt}`;
+                        });
+                        const finalDirPath = finalSegments.slice(0, -1).join(sep);
+                        const finalPath = finalSegments.join(sep);
+                        const newDirUrl = new URL(finalDirPath, functionsUrl);
+                        await fs.promises.mkdir(newDirUrl, { recursive: true });
+                        const oldFileUrl = new URL(`$astro/${outputFile}`, outputUrl);
+                        const newFileUrl = new URL(finalPath, functionsUrl);
+                        await fs.promises.rename(oldFileUrl, newFileUrl);
+                    }
+                }
+                else {
+                    const entryPath = fileURLToPath(new URL(_buildConfig.serverEntry, _buildConfig.server));
+                    const entryUrl = new URL(_buildConfig.serverEntry, _config.outDir);
+                    const buildPath = fileURLToPath(entryUrl);
+                    // A URL for the final build path after renaming
+                    const finalBuildUrl = pathToFileURL(buildPath.replace(/\.mjs$/, '.js'));
+                    await esbuild.build({
+                        target: 'es2022',
+                        platform: 'browser',
+                        conditions: ['workerd', 'worker', 'browser'],
+                        external: [
+                            'node:assert',
+                            'node:async_hooks',
+                            'node:buffer',
+                            'node:crypto',
+                            'node:diagnostics_channel',
+                            'node:events',
+                            'node:path',
+                            'node:process',
+                            'node:stream',
+                            'node:string_decoder',
+                            'node:util',
+                            'cloudflare:*',
+                        ],
+                        entryPoints: [entryPath],
+                        outfile: buildPath,
+                        allowOverwrite: true,
+                        format: 'esm',
+                        bundle: true,
+                        minify: _config.vite?.build?.minify !== false,
+                        banner: {
+                            js: `globalThis.process = {
+								argv: [],
+								env: {},
+							};`,
+                        },
+                        logOverride: {
+                            'ignored-bare-import': 'silent',
+                        },
+                        plugins: !args?.wasmModuleImports
+                            ? []
+                            : [
+                                rewriteWasmImportPath({
+                                    relativePathToAssets: isModeDirectory
+                                        ? relative(fileURLToPath(functionsUrl), fileURLToPath(assetsUrl))
+                                        : relative(fileURLToPath(_buildConfig.client), fileURLToPath(assetsUrl)),
+                                }),
+                            ],
+                    });
+                    // Rename to worker.js
+                    await fs.promises.rename(buildPath, finalBuildUrl);
+                    if (isModeDirectory) {
+                        const directoryUrl = new URL('[[path]].js', functionsUrl);
+                        await fs.promises.rename(finalBuildUrl, directoryUrl);
+                    }
+                }
+                // throw the server folder in the bin
+                const serverUrl = new URL(_buildConfig.server);
+                await fs.promises.rm(serverUrl, { recursive: true, force: true });
+                // move cloudflare specific files to the root
+                const cloudflareSpecialFiles = ['_headers', '_redirects', '_routes.json'];
+                if (_config.base !== '/') {
+                    for (const file of cloudflareSpecialFiles) {
+                        try {
+                            await fs.promises.rename(new URL(file, _buildConfig.client), new URL(file, _config.outDir));
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+                // Add also the worker file so it's excluded from the _routes.json generation
+                if (!isModeDirectory) {
+                    cloudflareSpecialFiles.push('_worker.js');
+                }
+                const routesExists = await fs.promises
+                    .stat(new URL('./_routes.json', _config.outDir))
+                    .then((stat) => stat.isFile())
+                    .catch(() => false);
+                // this creates a _routes.json, in case there is none present to enable
+                // cloudflare to handle static files and support _redirects configuration
+                if (!routesExists) {
+                    /**
+                     * These route types are candiates for being part of the `_routes.json` `include` array.
+                     */
+                    const potentialFunctionRouteTypes = ['endpoint', 'page'];
+                    const functionEndpoints = routes
+                        // Certain route types, when their prerender option is set to false, run on the server as function invocations
+                        .filter((route) => potentialFunctionRouteTypes.includes(route.type) && !route.prerender)
+                        .map((route) => {
+                        const includePattern = '/' +
+                            route.segments
+                                .flat()
+                                .map((segment) => (segment.dynamic ? '*' : segment.content))
+                                .join('/');
+                        const regexp = new RegExp('^\\/' +
+                            route.segments
+                                .flat()
+                                .map((segment) => (segment.dynamic ? '(.*)' : segment.content))
+                                .join('\\/') +
+                            '$');
+                        return {
+                            includePattern,
+                            regexp,
+                        };
+                    });
+                    const staticPathList = (await glob(`${fileURLToPath(_buildConfig.client)}/**/*`, {
+                        cwd: fileURLToPath(_config.outDir),
+                        filesOnly: true,
+                        dot: true,
+                    }))
+                        .filter((file) => cloudflareSpecialFiles.indexOf(file) < 0)
+                        .map((file) => `/${file.replace(/\\/g, '/')}`);
+                    for (let page of pages) {
+                        let pagePath = prependForwardSlash(page.pathname);
+                        if (_config.base !== '/') {
+                            const base = _config.base.endsWith('/') ? _config.base.slice(0, -1) : _config.base;
+                            pagePath = `${base}${pagePath}`;
+                        }
+                        staticPathList.push(pagePath);
+                    }
+                    const redirectsExists = await fs.promises
+                        .stat(new URL('./_redirects', _config.outDir))
+                        .then((stat) => stat.isFile())
+                        .catch(() => false);
+                    // convert all redirect source paths into a list of routes
+                    // and add them to the static path
+                    if (redirectsExists) {
+                        const redirects = (await fs.promises.readFile(new URL('./_redirects', _config.outDir), 'utf-8'))
+                            .split(os.EOL)
+                            .map((line) => {
+                            const parts = line.split(' ');
+                            if (parts.length < 2) {
+                                return null;
+                            }
+                            else {
+                                // convert /products/:id to /products/*
+                                return (parts[0]
+                                    .replace(/\/:.*?(?=\/|$)/g, '/*')
+                                    // remove query params as they are not supported by cloudflare
+                                    .replace(/\?.*$/, ''));
+                            }
+                        })
+                            .filter((line, index, arr) => line !== null && arr.indexOf(line) === index);
+                        if (redirects.length > 0) {
+                            staticPathList.push(...redirects);
+                        }
+                    }
+                    const redirectRoutes = routes
+                        .filter((r) => r.type === 'redirect')
+                        .map((r) => {
+                        return [r, ''];
+                    });
+                    const trueRedirects = createRedirectsFromAstroRoutes({
+                        config: _config,
+                        routeToDynamicTargetMap: new Map(Array.from(redirectRoutes)),
+                        dir,
+                    });
+                    if (!trueRedirects.empty()) {
+                        await fs.promises.appendFile(new URL('./_redirects', _config.outDir), trueRedirects.print());
+                    }
+                    staticPathList.push(...routes.filter((r) => r.type === 'redirect').map((r) => r.route));
+                    const strategy = args?.routes?.strategy ?? 'auto';
+                    // Strategy `include`: include all function endpoints, and then exclude static paths that would be matched by an include pattern
+                    const includeStrategy = strategy === 'exclude'
+                        ? undefined
+                        : {
+                            include: deduplicatePatterns(functionEndpoints
+                                .map((endpoint) => endpoint.includePattern)
+                                .concat(args?.routes?.include ?? [])),
+                            exclude: deduplicatePatterns(staticPathList
+                                .filter((file) => functionEndpoints.some((endpoint) => endpoint.regexp.test(file)))
+                                .concat(args?.routes?.exclude ?? [])),
+                        };
+                    // Cloudflare requires at least one include pattern:
+                    // https://developers.cloudflare.com/pages/platform/functions/routing/#limits
+                    // So we add a pattern that we immediately exclude again
+                    if (includeStrategy?.include.length === 0) {
+                        includeStrategy.include = ['/'];
+                        includeStrategy.exclude = ['/'];
+                    }
+                    // Strategy `exclude`: include everything, and then exclude all static paths
+                    const excludeStrategy = strategy === 'include'
+                        ? undefined
+                        : {
+                            include: ['/*'],
+                            exclude: deduplicatePatterns(staticPathList.concat(args?.routes?.exclude ?? [])),
+                        };
+                    const includeStrategyLength = includeStrategy
+                        ? includeStrategy.include.length + includeStrategy.exclude.length
+                        : Infinity;
+                    const excludeStrategyLength = excludeStrategy
+                        ? excludeStrategy.include.length + excludeStrategy.exclude.length
+                        : Infinity;
+                    const winningStrategy = includeStrategyLength <= excludeStrategyLength ? includeStrategy : excludeStrategy;
+                    await fs.promises.writeFile(new URL('./_routes.json', _config.outDir), JSON.stringify({
+                        version: 1,
+                        ...winningStrategy,
+                    }, null, 2));
+                }
+            },
+        },
+    };
+}

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare const isNode: boolean;
+export declare function getProcessEnvProxy(): {};

package/dist/util.js

@@ -0,0 +1,13 @@
+export const isNode = typeof process === 'object' && Object.prototype.toString.call(process) === '[object process]';
+export function getProcessEnvProxy() {
+    return new Proxy({}, {
+        get: (target, prop) => {
+            console.warn(
+            // NOTE: \0 prevents Vite replacement
+            `Unable to access \`import.meta\0.env.${prop.toString()}\` on initialization ` +
+                `as the Cloudflare platform only provides the environment variables per request. ` +
+                `Please move the environment variable access inside a function ` +
+                `that's only called after a request has been received.`);
+        },
+    });
+}

package/dist/utils/assets.d.ts

@@ -0,0 +1,14 @@
+import type { AstroConfig, ImageMetadata, RemotePattern } from 'astro';
+export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
+export declare function isRemotePath(src: string): boolean;
+export declare function matchHostname(url: URL, hostname?: string, allowWildcard?: boolean): boolean;
+export declare function matchPort(url: URL, port?: string): boolean;
+export declare function matchProtocol(url: URL, protocol?: string): boolean;
+export declare function matchPathname(url: URL, pathname?: string, allowWildcard?: boolean): boolean;
+export declare function matchPattern(url: URL, remotePattern: RemotePattern): boolean;
+export declare function isRemoteAllowed(src: string, { domains, remotePatterns, }: Partial<Pick<AstroConfig['image'], 'domains' | 'remotePatterns'>>): boolean;
+export declare function isString(path: unknown): path is string;
+export declare function removeTrailingForwardSlash(path: string): string;
+export declare function removeLeadingForwardSlash(path: string): string;
+export declare function trimSlashes(path: string): string;
+export declare function joinPaths(...paths: (string | undefined)[]): string;

package/dist/utils/assets.js

@@ -0,0 +1,95 @@
+export function isESMImportedImage(src) {
+    return typeof src === 'object';
+}
+export function isRemotePath(src) {
+    return /^(http|ftp|https|ws):?\/\//.test(src) || src.startsWith('data:');
+}
+export function matchHostname(url, hostname, allowWildcard) {
+    if (!hostname) {
+        return true;
+    }
+    else if (!allowWildcard || !hostname.startsWith('*')) {
+        return hostname === url.hostname;
+    }
+    else if (hostname.startsWith('**.')) {
+        const slicedHostname = hostname.slice(2); // ** length
+        return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
+    }
+    else if (hostname.startsWith('*.')) {
+        const slicedHostname = hostname.slice(1); // * length
+        const additionalSubdomains = url.hostname
+            .replace(slicedHostname, '')
+            .split('.')
+            .filter(Boolean);
+        return additionalSubdomains.length === 1;
+    }
+    return false;
+}
+export function matchPort(url, port) {
+    return !port || port === url.port;
+}
+export function matchProtocol(url, protocol) {
+    return !protocol || protocol === url.protocol.slice(0, -1);
+}
+export function matchPathname(url, pathname, allowWildcard) {
+    if (!pathname) {
+        return true;
+    }
+    else if (!allowWildcard || !pathname.endsWith('*')) {
+        return pathname === url.pathname;
+    }
+    else if (pathname.endsWith('/**')) {
+        const slicedPathname = pathname.slice(0, -2); // ** length
+        return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
+    }
+    else if (pathname.endsWith('/*')) {
+        const slicedPathname = pathname.slice(0, -1); // * length
+        const additionalPathChunks = url.pathname
+            .replace(slicedPathname, '')
+            .split('/')
+            .filter(Boolean);
+        return additionalPathChunks.length === 1;
+    }
+    return false;
+}
+export function matchPattern(url, remotePattern) {
+    return (matchProtocol(url, remotePattern.protocol) &&
+        matchHostname(url, remotePattern.hostname, true) &&
+        matchPort(url, remotePattern.port) &&
+        matchPathname(url, remotePattern.pathname, true));
+}
+export function isRemoteAllowed(src, { domains = [], remotePatterns = [], }) {
+    if (!isRemotePath(src))
+        return false;
+    const url = new URL(src);
+    return (domains.some((domain) => matchHostname(url, domain)) ||
+        remotePatterns.some((remotePattern) => matchPattern(url, remotePattern)));
+}
+export function isString(path) {
+    return typeof path === 'string' || path instanceof String;
+}
+export function removeTrailingForwardSlash(path) {
+    return path.endsWith('/') ? path.slice(0, path.length - 1) : path;
+}
+export function removeLeadingForwardSlash(path) {
+    return path.startsWith('/') ? path.substring(1) : path;
+}
+export function trimSlashes(path) {
+    return path.replace(/^\/|\/$/g, '');
+}
+export function joinPaths(...paths) {
+    return paths
+        .filter(isString)
+        .map((path, i) => {
+        if (i === 0) {
+            return removeTrailingForwardSlash(path);
+        }
+        else if (i === paths.length - 1) {
+            return removeLeadingForwardSlash(path);
+        }
+        else {
+            return trimSlashes(path);
+        }
+    })
+        .join('/');
+}

package/dist/utils/deduplicatePatterns.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Remove duplicates and redundant patterns from an `include` or `exclude` list.
+ * Otherwise Cloudflare will throw an error on deployment. Plus, it saves more entries.
+ * E.g. `['/foo/*', '/foo/*', '/foo/bar'] => ['/foo/*']`
+ * @param patterns a list of `include` or `exclude` patterns
+ * @returns a deduplicated list of patterns
+ */
+export declare function deduplicatePatterns(patterns: string[]): string[];