putmein-test 1.0.0

package/dist/ray/node_modules/next/dist/server/lib/chrome-devtools-workspace.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    handleChromeDevtoolsWorkspaceRequest: null,
+    isChromeDevtoolsWorkspaceUrl: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    handleChromeDevtoolsWorkspaceRequest: function() {
+        return handleChromeDevtoolsWorkspaceRequest;
+    },
+    isChromeDevtoolsWorkspaceUrl: function() {
+        return isChromeDevtoolsWorkspaceUrl;
+    }
+});
+const _crypto = require("crypto");
+const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _cachedir = require("../cache-dir");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+// Keep the uuid in memory as it should never change during the lifetime of the server.
+let workspaceUUID = null;
+function isChromeDevtoolsWorkspaceUrl(pathname) {
+    return pathname === '/.well-known/appspecific/com.chrome.devtools.json';
+}
+async function handleChromeDevtoolsWorkspaceRequest(response, opts, config) {
+    response.setHeader('Content-Type', 'application/json');
+    response.end(JSON.stringify(await getChromeDevtoolsWorkspace(opts.dir, config.distDir), null, 2));
+}
+/**
+ * For https://developer.chrome.com/docs/devtools/workspaces
+ */ async function getChromeDevtoolsWorkspace(root, configDistDir) {
+    if (workspaceUUID === null) {
+        const distDir = _path.join(root, configDistDir);
+        const cacheBaseDir = (0, _cachedir.getStorageDirectory)(distDir);
+        if (cacheBaseDir === undefined) {
+            workspaceUUID = (0, _crypto.randomUUID)();
+        } else {
+            const cachedUUIDPath = _path.join(cacheBaseDir, 'chrome-devtools-workspace-uuid');
+            try {
+                workspaceUUID = await _fs.promises.readFile(cachedUUIDPath, 'utf8');
+            } catch  {
+                // TODO: Why does this need to be v4 and not v5?
+                // With v5 we could base it off of the `distDir` and `root` which would
+                // allow us to persist the workspace across .next wipes.
+                workspaceUUID = (0, _crypto.randomUUID)();
+                try {
+                    await _fs.promises.writeFile(cachedUUIDPath, workspaceUUID, 'utf8');
+                } catch (cause) {
+                    console.warn(Object.defineProperty(new Error('Failed to persist Chrome DevTools workspace UUID. The Chrome DevTools Workspace needs to be reconnected after the next page reload.', {
+                        cause
+                    }), "__NEXT_ERROR_CODE", {
+                        value: "E708",
+                        enumerable: false,
+                        configurable: true
+                    }));
+                }
+            }
+        }
+    }
+    return {
+        workspace: {
+            uuid: workspaceUUID,
+            root
+        }
+    };
+}
+
+//# sourceMappingURL=chrome-devtools-workspace.js.map

package/dist/ray/node_modules/next/dist/server/lib/clone-response.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cloneResponse", {
+    enumerable: true,
+    get: function() {
+        return cloneResponse;
+    }
+});
+const noop = ()=>{};
+let registry;
+if (globalThis.FinalizationRegistry) {
+    registry = new FinalizationRegistry((weakRef)=>{
+        const stream = weakRef.deref();
+        if (stream && !stream.locked) {
+            stream.cancel('Response object has been garbage collected').then(noop);
+        }
+    });
+}
+function cloneResponse(original) {
+    // If the response has no body, then we can just return the original response
+    // twice because it's immutable.
+    if (!original.body) {
+        return [
+            original,
+            original
+        ];
+    }
+    const [body1, body2] = original.body.tee();
+    const cloned1 = new Response(body1, {
+        status: original.status,
+        statusText: original.statusText,
+        headers: original.headers
+    });
+    Object.defineProperty(cloned1, 'url', {
+        value: original.url,
+        // How the original response.url behaves
+        configurable: true,
+        enumerable: true,
+        writable: false
+    });
+    const cloned2 = new Response(body2, {
+        status: original.status,
+        statusText: original.statusText,
+        headers: original.headers
+    });
+    Object.defineProperty(cloned2, 'url', {
+        value: original.url,
+        // How the original response.url behaves
+        configurable: true,
+        enumerable: true,
+        writable: false
+    });
+    // The Fetch Standard allows users to skip consuming the response body by
+    // relying on garbage collection to release connection resources.
+    // https://github.com/nodejs/undici?tab=readme-ov-file#garbage-collection
+    //
+    // To cancel the stream you then need to cancel both resulting branches.
+    // Teeing a stream will generally lock it for the duration, preventing other
+    // readers from locking it.
+    // https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/tee
+    if (registry) {
+        if (cloned1.body) {
+            registry.register(cloned1, new WeakRef(cloned1.body));
+        }
+        if (cloned2.body) {
+            registry.register(cloned2, new WeakRef(cloned2.body));
+        }
+    }
+    return [
+        cloned1,
+        cloned2
+    ];
+}
+
+//# sourceMappingURL=clone-response.js.map

package/dist/ray/node_modules/next/dist/server/lib/cpu-profile.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "saveCpuProfile", {
+    enumerable: true,
+    get: function() {
+        return saveCpuProfile;
+    }
+});
+const privateCpuProfileName = process.env.__NEXT_PRIVATE_CPU_PROFILE;
+const isCpuProfileEnabled = process.env.NEXT_CPU_PROF || privateCpuProfileName;
+const cpuProfileDir = process.env.NEXT_CPU_PROF_DIR;
+let session = null;
+let profileSaved = false;
+if (isCpuProfileEnabled) {
+    const { Session } = require('inspector');
+    session = new Session();
+    session.connect();
+    session.post('Profiler.enable');
+    session.post('Profiler.start');
+    process.on('exit', ()=>{
+        saveCpuProfile();
+    });
+}
+function saveCpuProfile() {
+    if (!session || profileSaved || !isCpuProfileEnabled) {
+        return;
+    }
+    profileSaved = true;
+    const fs = require('fs');
+    const path = require('path');
+    session.post('Profiler.stop', (error, param)=>{
+        if (error) {
+            console.error('Cannot generate CPU profiling:', error);
+            return;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        const baseName = privateCpuProfileName || 'cpu-profile';
+        const filename = `${baseName}-${timestamp}.cpuprofile`;
+        let outputPath;
+        if (cpuProfileDir) {
+            // The CLI created `cpuProfileDir` (with its `.gitignore`) before setting
+            // NEXT_CPU_PROF_DIR, so it already exists in these build workers.
+            outputPath = path.join(cpuProfileDir, filename);
+        } else {
+            outputPath = `./${filename}`;
+        }
+        fs.writeFileSync(outputPath, JSON.stringify(param.profile));
+        const { green } = require('../../lib/picocolors');
+        console.log(`\n${green('CPU profile saved:')} ${outputPath}`);
+        console.log('Open in Chrome DevTools → Performance tab → Load profile');
+    });
+}
+
+//# sourceMappingURL=cpu-profile.js.map

package/dist/ray/node_modules/next/dist/server/lib/decode-query-path-parameter.js

@@ -0,0 +1,26 @@
+/**
+ * Decodes a query path parameter.
+ *
+ * @param value - The value to decode.
+ * @returns The decoded value.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "decodeQueryPathParameter", {
+    enumerable: true,
+    get: function() {
+        return decodeQueryPathParameter;
+    }
+});
+function decodeQueryPathParameter(value) {
+    // When deployed to Vercel, the value may be encoded, so this attempts to
+    // decode it and returns the original value if it fails.
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return value;
+    }
+}
+
+//# sourceMappingURL=decode-query-path-parameter.js.map

package/dist/ray/node_modules/next/dist/server/lib/dedupe-fetch.js

@@ -0,0 +1,163 @@
+/**
+ * Based on https://github.com/facebook/react/blob/d4e78c42a94be027b4dc7ed2659a5fddfbf9bd4e/packages/react/src/ReactFetch.js
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createDedupeFetch", {
+    enumerable: true,
+    get: function() {
+        return createDedupeFetch;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _cloneresponse = require("./clone-response");
+const _invarianterror = require("../../shared/lib/invariant-error");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]' // generateCacheKey(new Request('https://blank'));
+;
+// Headers that should not affect deduplication
+// traceparent and tracestate are used for distributed tracing and should not affect cache keys
+const headersToExcludeInCacheKey = new Set([
+    'traceparent',
+    'tracestate'
+]);
+function generateCacheKey(request) {
+    // We pick the fields that goes into the key used to dedupe requests.
+    // We don't include the `cache` field, because we end up using whatever
+    // caching resulted from the first request.
+    // Notably we currently don't consider non-standard (or future) options.
+    // This might not be safe. TODO: warn for non-standard extensions differing.
+    // IF YOU CHANGE THIS UPDATE THE simpleCacheKey ABOVE.
+    const filteredHeaders = Array.from(request.headers.entries()).filter(([key])=>!headersToExcludeInCacheKey.has(key.toLowerCase()));
+    return JSON.stringify([
+        request.method,
+        filteredHeaders,
+        request.mode,
+        request.redirect,
+        request.credentials,
+        request.referrer,
+        request.referrerPolicy,
+        request.integrity
+    ]);
+}
+function createDedupeFetch(originalFetch) {
+    const getCacheEntries = _react.cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key
+    (url)=>[]);
+    return function dedupeFetch(resource, options) {
+        if (options && options.signal) {
+            // If we're passed a signal, then we assume that
+            // someone else controls the lifetime of this object and opts out of
+            // caching. It's effectively the opt-out mechanism.
+            // Ideally we should be able to check this on the Request but
+            // it always gets initialized with its own signal so we don't
+            // know if it's supposed to override - unless we also override the
+            // Request constructor.
+            return originalFetch(resource, options);
+        }
+        // Normalize the Request
+        let url;
+        let cacheKey;
+        if (typeof resource === 'string' && !options) {
+            // Fast path.
+            cacheKey = simpleCacheKey;
+            url = resource;
+        } else {
+            // Normalize the request.
+            // if resource is not a string or a URL (its an instance of Request)
+            // then do not instantiate a new Request but instead
+            // reuse the request as to not disturb the body in the event it's a ReadableStream.
+            const request = typeof resource === 'string' || resource instanceof URL ? new Request(resource, options) : resource;
+            if (request.method !== 'GET' && request.method !== 'HEAD' || request.keepalive) {
+                // We currently don't dedupe requests that might have side-effects. Those
+                // have to be explicitly cached. We assume that the request doesn't have a
+                // body if it's GET or HEAD.
+                // keepalive gets treated the same as if you passed a custom cache signal.
+                return originalFetch(resource, options);
+            }
+            cacheKey = generateCacheKey(request);
+            url = request.url;
+        }
+        const cacheEntries = getCacheEntries(url);
+        for(let i = 0, j = cacheEntries.length; i < j; i += 1){
+            const [key, promise] = cacheEntries[i];
+            if (key === cacheKey) {
+                return promise.then(()=>{
+                    const response = cacheEntries[i][2];
+                    if (!response) throw Object.defineProperty(new _invarianterror.InvariantError('No cached response'), "__NEXT_ERROR_CODE", {
+                        value: "E579",
+                        enumerable: false,
+                        configurable: true
+                    });
+                    // We're cloning the response using this utility because there exists
+                    // a bug in the undici library around response cloning. See the
+                    // following pull request for more details:
+                    // https://github.com/vercel/next.js/pull/73274
+                    const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+                    cacheEntries[i][2] = cloned2;
+                    return cloned1;
+                });
+            }
+        }
+        // We pass the original arguments here in case normalizing the Request
+        // doesn't include all the options in this environment.
+        const promise = originalFetch(resource, options);
+        const entry = [
+            cacheKey,
+            promise,
+            null
+        ];
+        cacheEntries.push(entry);
+        return promise.then((response)=>{
+            // We're cloning the response using this utility because there exists
+            // a bug in the undici library around response cloning. See the
+            // following pull request for more details:
+            // https://github.com/vercel/next.js/pull/73274
+            const [cloned1, cloned2] = (0, _cloneresponse.cloneResponse)(response);
+            entry[2] = cloned2;
+            return cloned1;
+        });
+    };
+}
+
+//# sourceMappingURL=dedupe-fetch.js.map

package/dist/ray/node_modules/next/dist/server/lib/dev-bundler-service.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DevBundlerService", {
+    enumerable: true,
+    get: function() {
+        return DevBundlerService;
+    }
+});
+const _lrucache = require("./lru-cache");
+const _mockrequest = require("./mock-request");
+const _hotreloadertypes = require("../dev/hot-reloader-types");
+const _requestinsights = require("./trace/request-insights");
+class DevBundlerService {
+    constructor(bundler, handler, requestInsightsEnabled){
+        this.bundler = bundler;
+        this.handler = handler;
+        this.close = ()=>{
+            this.unsubscribeRequestInsights == null ? void 0 : this.unsubscribeRequestInsights.call(this);
+            this.bundler.hotReloader.close();
+        };
+        this.ensurePage = async (definition)=>{
+            // TODO: remove after ensure is pulled out of server
+            return await this.bundler.hotReloader.ensurePage(definition);
+        };
+        this.logErrorWithOriginalStack = this.bundler.logErrorWithOriginalStack.bind(this.bundler);
+        this.appIsrManifestInner = new _lrucache.LRUCache(8000, function length() {
+            return 16;
+        });
+        const { hotReloader } = bundler;
+        this.setCacheStatus = hotReloader.setCacheStatus.bind(hotReloader);
+        this.setReactDebugChannel = hotReloader.setReactDebugChannel.bind(hotReloader);
+        this.sendErrorsToBrowser = hotReloader.sendErrorsToBrowser.bind(hotReloader);
+        if (requestInsightsEnabled) {
+            this.unsubscribeRequestInsights = (0, _requestinsights.subscribeRequestInsights)((insight)=>{
+                hotReloader.send({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_INSIGHTS_UPDATE,
+                    insight
+                });
+            });
+        }
+    }
+    getServerComponentsHmrRefreshHash() {
+        return this.bundler.hotReloader.getServerComponentsHmrRefreshHash();
+    }
+    async getFallbackErrorComponents(url) {
+        await this.bundler.hotReloader.buildFallbackError();
+        // Build the error page to ensure the fallback is built too.
+        // TODO: See if this can be moved into hotReloader or removed.
+        await this.bundler.hotReloader.ensurePage({
+            page: '/_error',
+            clientOnly: false,
+            definition: undefined,
+            url
+        });
+    }
+    async getCompilationError(page) {
+        const errors = await this.bundler.hotReloader.getCompilationErrors(page);
+        if (!errors) return;
+        // Return the very first error we found.
+        return errors[0];
+    }
+    async revalidate({ urlPath, headers, opts: revalidateOpts }) {
+        const mocked = (0, _mockrequest.createRequestResponseMocks)({
+            url: urlPath,
+            headers
+        });
+        await this.handler(mocked.req, mocked.res);
+        await mocked.res.hasStreamed;
+        if (mocked.res.getHeader('x-nextjs-cache') !== 'REVALIDATED' && mocked.res.statusCode !== 200 && !(mocked.res.statusCode === 404 && revalidateOpts.unstable_onlyGenerated)) {
+            throw Object.defineProperty(new Error(`Invalid response ${mocked.res.statusCode}`), "__NEXT_ERROR_CODE", {
+                value: "E175",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return {};
+    }
+    get appIsrManifest() {
+        const serializableManifest = {};
+        for (const [key, value] of this.appIsrManifestInner){
+            serializableManifest[key] = value;
+        }
+        return serializableManifest;
+    }
+    setIsrStatus(key, value) {
+        var // Only send the ISR manifest to legacy clients, i.e. Pages Router clients,
+        // or App Router clients that have Cache Components disabled. The ISR
+        // manifest is only used to inform the static indicator, which currently
+        // does not provide useful information if Cache Components is enabled due to
+        // its binary nature (i.e. it does not support showing info for partially
+        // static pages).
+        _this_bundler_hotReloader, _this_bundler;
+        if (value === undefined) {
+            this.appIsrManifestInner.remove(key);
+        } else {
+            this.appIsrManifestInner.set(key, value);
+        }
+        (_this_bundler = this.bundler) == null ? void 0 : (_this_bundler_hotReloader = _this_bundler.hotReloader) == null ? void 0 : _this_bundler_hotReloader.sendToLegacyClients({
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ISR_MANIFEST,
+            data: this.appIsrManifest
+        });
+    }
+    sendHmrMessage(message) {
+        this.bundler.hotReloader.send(message);
+    }
+}
+
+//# sourceMappingURL=dev-bundler-service.js.map

package/dist/ray/node_modules/next/dist/server/lib/disk-lru-cache.external.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getOrInitDiskLRU: null,
+    resetDiskLRU: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getOrInitDiskLRU: function() {
+        return getOrInitDiskLRU;
+    },
+    resetDiskLRU: function() {
+        return resetDiskLRU;
+    }
+});
+const _fs = require("fs");
+const _lrucache = require("./lru-cache");
+/**
+ * Module-level LRU singleton for disk cache eviction.
+ * Initialized once on first `set()`, shared across all consumers.
+ * Once resolved, the promise stays resolved — subsequent calls just await the cached result.
+ */ let _diskLRUPromise = null;
+async function getOrInitDiskLRU(cacheDir, maxDiskSize, readEntries, evictEntry) {
+    if (!_diskLRUPromise) {
+        _diskLRUPromise = (async ()=>{
+            let maxSize = maxDiskSize;
+            if (typeof maxSize === 'undefined') {
+                // Ensure cacheDir exists before checking disk space
+                await _fs.promises.mkdir(cacheDir, {
+                    recursive: true
+                });
+                // Since config was not provided, default to 50% of available disk space
+                const { bavail, bsize } = await _fs.promises.statfs(cacheDir);
+                maxSize = Math.floor(bavail * bsize / 2);
+            }
+            const lru = new _lrucache.LRUCache(maxSize, (size)=>size, (cacheKey)=>evictEntry(cacheDir, cacheKey));
+            const entries = await readEntries(cacheDir);
+            for (const entry of entries){
+                lru.set(entry.key, entry.size);
+            }
+            return lru;
+        })();
+    }
+    return _diskLRUPromise;
+}
+function resetDiskLRU() {
+    _diskLRUPromise = null;
+}
+
+//# sourceMappingURL=disk-lru-cache.external.js.map

package/dist/ray/node_modules/next/dist/server/lib/encode-header-safe.js

@@ -0,0 +1,44 @@
+/**
+ * Percent-encode every character other than horizontal tab and printable ASCII
+ * so a value can be safely serialized into an HTTP header.
+ *
+ * Node's `validateHeaderValue` and `fetch`'s ByteString conversion accept
+ * different character ranges. Restricting values to `\t\x20-\x7e` produces a
+ * conservative representation that both can serialize. Characters outside a
+ * transport's accepted range (Hebrew, Arabic, Chinese, emoji, …) would
+ * otherwise throw `ERR_INVALID_CHAR` or a `TypeError`, which crashes ISR or
+ * fails a cache read on every affected request.
+ *
+ * Cache tags are encoded at the public boundaries — tag construction
+ * (`getImplicitTags`, `validateTags`) and invalidation input
+ * (`revalidatePath`, `revalidateTag`, `updateTag`) — so storage, comparison,
+ * and the wire all see the same canonical form.
+ *
+ * The class is narrower than either transport accepts. Everything inside it
+ * passes through byte-for-byte, including `,`, `/`, `%`, `[`, `]`, `_`, `-` and
+ * `\t`, which preserves the comma-separated header format and the
+ * dynamic-segment markers in derived tags (`_N_T_/[slug]/page`).
+ *
+ * Properties:
+ * - Fast-path: input that already fits the class is returned unchanged. This
+ *   makes the encoder idempotent on already-encoded `%xx` sequences.
+ * - Matches *runs* of out-of-class code units so surrogate pairs (e.g. an
+ *   emoji) are handed to `encodeURIComponent` as a complete code point — a
+ *   per-code-unit regex would split the pair and throw `URIError`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodeHeaderSafe", {
+    enumerable: true,
+    get: function() {
+        return encodeHeaderSafe;
+    }
+});
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeHeaderSafe(value) {
+    return OUT_OF_CLASS_CHAR.test(value) ? value.replace(OUT_OF_CLASS_RUN, (run)=>encodeURIComponent(run)) : value;
+}
+
+//# sourceMappingURL=encode-header-safe.js.map