@bleedingdev/modern-js-runtime-extensions 3.8.3-ultramodern.2

package/dist/cjs/shellStream.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createConservingWebShellStream: ()=>createConservingWebShellStream
+});
+const external_rendererHead_js_namespaceObject = require("./rendererHead.js");
+const MISSING_SHELL_MARKER_ERROR = 'React SSR stream ended before the shell marker';
+const createConservingWebShellStream = (source, context, marker, onMissingMarker)=>{
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const headProcessor = (0, external_rendererHead_js_namespaceObject.createHeadChunkProcessor)(context);
+    let markerCarry = '';
+    let markerFound = false;
+    const observeMarker = (chunk)=>{
+        if (markerFound) return;
+        const candidate = markerCarry + chunk;
+        markerFound = candidate.includes(marker);
+        markerCarry = markerFound ? '' : candidate.slice(-(marker.length - 1));
+    };
+    return source.pipeThrough(new TransformStream({
+        transform (chunk, controller) {
+            const decoded = decoder.decode(chunk, {
+                stream: true
+            });
+            observeMarker(decoded);
+            const output = headProcessor.push(decoded);
+            if (output) controller.enqueue(encoder.encode(output));
+        },
+        flush (controller) {
+            const decoded = decoder.decode();
+            observeMarker(decoded);
+            if (!markerFound) {
+                (0, external_rendererHead_js_namespaceObject.abortHeadRender)(context);
+                const error = new Error(MISSING_SHELL_MARKER_ERROR);
+                onMissingMarker?.(error);
+                throw error;
+            }
+            const output = headProcessor.finish(decoded);
+            if (output) controller.enqueue(encoder.encode(output));
+        }
+    }));
+};
+exports.createConservingWebShellStream = __webpack_exports__.createConservingWebShellStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createConservingWebShellStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/helmetCompat.mjs

@@ -0,0 +1,357 @@
+const CONTENT_PROPERTIES = new Set([
+    'innerHTML',
+    'cssText'
+]);
+const HTML_ATTRIBUTE_NAMES = {
+    charSet: 'charset',
+    className: 'class',
+    contentEditable: 'contenteditable',
+    httpEquiv: 'http-equiv',
+    hrefLang: 'hreflang',
+    itemProp: 'itemprop',
+    tabIndex: 'tabindex'
+};
+const REACT_ATTRIBUTE_NAMES = {
+    accesskey: 'accessKey',
+    charset: 'charSet',
+    class: 'className',
+    contenteditable: 'contentEditable',
+    contextmenu: 'contextMenu',
+    'http-equiv': 'httpEquiv',
+    hreflang: 'hrefLang',
+    itemprop: 'itemProp',
+    tabindex: 'tabIndex'
+};
+const SEO_PRIORITY_VALUES = {
+    link: {
+        rel: [
+            'amphtml',
+            'canonical',
+            'alternate'
+        ]
+    },
+    meta: {
+        charset: [
+            ''
+        ],
+        name: [
+            'generator',
+            'robots',
+            "description"
+        ],
+        property: [
+            'og:type',
+            'og:title',
+            'og:url',
+            'og:image',
+            'og:image:alt',
+            "og:description",
+            'twitter:url',
+            'twitter:title',
+            "twitter:description",
+            'twitter:image',
+            'twitter:image:alt',
+            'twitter:card',
+            'twitter:site'
+        ]
+    },
+    script: {
+        type: [
+            'application/ld+json'
+        ]
+    }
+};
+const TAG_PRIMARY_ATTRIBUTES = {
+    link: [
+        'rel',
+        'href'
+    ],
+    meta: [
+        'name',
+        'charset',
+        'http-equiv',
+        'property',
+        'itemprop'
+    ],
+    noscript: [
+        'innerHTML'
+    ],
+    script: [
+        'src',
+        'innerHTML'
+    ],
+    style: [
+        'cssText'
+    ]
+};
+const priorityRecords = new WeakSet();
+const priorityTags = new WeakSet();
+const immediateRecords = new WeakMap();
+const createElementFactory = (react)=>react.createElement;
+const renderHeadMarker = (react, marker)=>marker ? createElementFactory(react)('template', marker) : null;
+const toReactAttributes = (tag)=>{
+    const props = {};
+    for (const [attribute, value] of Object.entries(tag))if (!CONTENT_PROPERTIES.has(attribute)) props[REACT_ATTRIBUTE_NAMES[attribute] ?? attribute] = value;
+    return props;
+};
+const toReactProps = (tag, key)=>{
+    const props = {
+        ...toReactAttributes(tag),
+        key,
+        'data-rh': true
+    };
+    if ('innerHTML' in tag || 'cssText' in tag) props.dangerouslySetInnerHTML = {
+        __html: tag.innerHTML ?? tag.cssText ?? ''
+    };
+    return props;
+};
+const escapeHtml = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const toHtmlAttributeName = (name)=>HTML_ATTRIBUTE_NAMES[name] ?? name;
+const attributesToString = (tag, includeHelmetAttribute = false)=>{
+    const attributes = includeHelmetAttribute ? [
+        'data-rh="true"'
+    ] : [];
+    for (const [name, value] of Object.entries(tag)){
+        if (CONTENT_PROPERTIES.has(name) || false === value || null == value) continue;
+        const attribute = toHtmlAttributeName(name);
+        attributes.push(true === value ? attribute : `${attribute}="${escapeHtml(value)}"`);
+    }
+    return attributes.join(' ');
+};
+const tagsToString = (tagName, tags)=>tags.map((tag)=>{
+        const attributes = attributesToString(tag, true);
+        if (("script" === tagName || "noscript" === tagName) && 'string' == typeof tag.innerHTML) return `<${tagName} ${attributes}>${tag.innerHTML}</${tagName}>`;
+        if ('style' === tagName && 'string' == typeof tag.cssText) return `<style ${attributes}>${tag.cssText}</style>`;
+        return `<${tagName} ${attributes}>`;
+    }).join('');
+const markPriorityHeadRecord = (record, prioritize)=>{
+    if (prioritize) priorityRecords.add(record);
+};
+const isPriorityHeadTag = (tag)=>priorityTags.has(tag);
+const headTagsToComponents = (react, tagName, tags)=>{
+    const createElement = createElementFactory(react);
+    return tags.filter((tag)=>!priorityTags.has(tag)).map((tag, index)=>createElement(tagName, toReactProps(tag, index)));
+};
+const headTitleToComponent = (react, title, attributes)=>{
+    if (!title) return [];
+    const createElement = createElementFactory(react);
+    return [
+        createElement('title', toReactProps(attributes, title), title)
+    ];
+};
+const normalizedEntries = (tag)=>Object.entries(tag).map(([name, value])=>[
+            toHtmlAttributeName(name).toLowerCase(),
+            String(value).toLowerCase()
+        ]);
+const isSeoPriorityTag = (tagName, tag)=>{
+    const values = SEO_PRIORITY_VALUES[tagName];
+    return normalizedEntries(tag).some(([name, value])=>{
+        const allowed = values[name];
+        return void 0 !== allowed && ('charset' === name || allowed.includes(value));
+    });
+};
+const createPriorityHeadDatum = (react, records, dedupe)=>{
+    if (!records.some((record)=>'object' == typeof record && null !== record && priorityRecords.has(record))) return {
+        toComponent: ()=>[],
+        toString: ()=>''
+    };
+    const groups = [
+        'meta',
+        'link',
+        "script"
+    ].map((tagName)=>({
+            tagName,
+            tags: dedupe(tagName, records).filter((tag)=>isSeoPriorityTag(tagName, tag))
+        }));
+    for (const { tags } of groups)for (const tag of tags)priorityTags.add(tag);
+    const createElement = createElementFactory(react);
+    return {
+        toComponent: ()=>groups.flatMap(({ tagName, tags })=>tags.map((tag, index)=>createElement(tagName, toReactProps(tag, `${tagName}-${index}`)))),
+        toString: ()=>groups.map(({ tagName, tags })=>tagsToString(tagName, tags)).join('')
+    };
+};
+const createDatum = (react, tagName, tags)=>({
+        toComponent: ()=>headTagsToComponents(react, tagName, tags),
+        toString: ()=>tagsToString(tagName, tags.filter((tag)=>!priorityTags.has(tag)))
+    });
+const createAttributeDatum = (attributes)=>({
+        toComponent: ()=>toReactAttributes(attributes),
+        toString: ()=>attributesToString(attributes)
+    });
+const createTitleDatum = (react, title, attributes)=>({
+        toComponent: ()=>headTitleToComponent(react, title, attributes),
+        toString: ()=>{
+            if (!title) return '';
+            const serialized = attributesToString(attributes, true);
+            return `<title ${serialized}>${escapeHtml(title)}</title>`;
+        }
+    });
+const normalizeHelmetTitle = (title)=>{
+    if ('string' == typeof title) return title;
+    if (Array.isArray(title)) return title.map((part)=>String(part)).join('');
+};
+const mergeAttributes = (current, next)=>({
+        ...current,
+        ...next ?? {}
+    });
+const isHeadElement = (value)=>'object' == typeof value && null !== value && 'type' in value && 'props' in value && 'object' == typeof value.props && null !== value.props;
+const collectChildren = (react, children, draft)=>{
+    react.Children.forEach(children, (child)=>{
+        if (!react.isValidElement(child) || !isHeadElement(child)) return;
+        const element = child;
+        if (element.type === react.Fragment) return void collectChildren(react, element.props.children, draft);
+        if ('string' != typeof element.type) return;
+        const { children: nestedChildren, ...props } = element.props;
+        if ('title' === element.type) {
+            draft.title = react.Children.toArray(nestedChildren).join('');
+            draft.titleAttributes = mergeAttributes(draft.titleAttributes, props);
+            return;
+        }
+        if ('html' === element.type) {
+            draft.htmlAttributes = mergeAttributes(draft.htmlAttributes ?? {}, props);
+            return;
+        }
+        if ('body' === element.type) {
+            draft.bodyAttributes = mergeAttributes(draft.bodyAttributes ?? {}, props);
+            return;
+        }
+        if ('base' === element.type || 'link' === element.type || 'meta' === element.type || "noscript" === element.type || "script" === element.type || 'style' === element.type) {
+            const tag = {
+                ...props
+            };
+            if (("script" === element.type || 'style' === element.type || "noscript" === element.type) && 'string' == typeof nestedChildren) tag['style' === element.type ? 'cssText' : 'innerHTML'] = nestedChildren;
+            draft[element.type].push(tag);
+        }
+    });
+};
+const createHelmetRecord = (reactValue, props)=>{
+    const draft = {
+        base: void 0 === props.base ? [] : [
+            {
+                ...props.base
+            }
+        ],
+        bodyAttributes: void 0 === props.bodyAttributes ? void 0 : {
+            ...props.bodyAttributes
+        },
+        htmlAttributes: void 0 === props.htmlAttributes ? void 0 : {
+            ...props.htmlAttributes
+        },
+        link: (props.link ?? []).map((tag)=>({
+                ...tag
+            })),
+        meta: (props.meta ?? []).map((tag)=>({
+                ...tag
+            })),
+        noscript: (props.noscript ?? []).map((tag)=>({
+                ...tag
+            })),
+        script: (props.script ?? []).map((tag)=>({
+                ...tag
+            })),
+        style: (props.style ?? []).map((tag)=>({
+                ...tag
+            })),
+        title: normalizeHelmetTitle(props.title),
+        titleAttributes: {
+            ...props.titleAttributes ?? {}
+        }
+    };
+    collectChildren(reactValue, props.children, draft);
+    const record = {
+        ...draft,
+        defaultTitle: props.defaultTitle,
+        prioritizeSeoTags: true === props.prioritizeSeoTags,
+        titleTemplate: props.titleTemplate
+    };
+    markPriorityHeadRecord(record, record.prioritizeSeoTags);
+    return record;
+};
+const getInnermostDefined = (records, pick)=>{
+    for(let index = records.length - 1; index >= 0; index -= 1){
+        const value = pick(records[index]);
+        if (void 0 !== value) return value;
+    }
+};
+const deriveTitle = (records)=>{
+    const title = getInnermostDefined(records, (record)=>record.title);
+    const template = getInnermostDefined(records, (record)=>record.titleTemplate);
+    if (template && title) return template.replaceAll('%s', title);
+    return title || getInnermostDefined(records, (record)=>record.defaultTitle);
+};
+const mergeRecordAttributes = (records, pick)=>records.reduce((merged, record)=>mergeAttributes(merged, pick(record)), {});
+const deriveBaseTags = (records)=>{
+    for(let recordIndex = records.length - 1; recordIndex >= 0; recordIndex--){
+        const tags = records[recordIndex].base;
+        for(let tagIndex = tags.length - 1; tagIndex >= 0; tagIndex--)if (tags[tagIndex].href) return [
+            tags[tagIndex]
+        ];
+    }
+    return [];
+};
+const getPrimaryAttribute = (tagName, tag)=>{
+    const candidates = TAG_PRIMARY_ATTRIBUTES[tagName];
+    let selectedKey;
+    let selectedValue;
+    for (const [key, value] of Object.entries(tag)){
+        const normalizedKey = CONTENT_PROPERTIES.has(key) ? key : toHtmlAttributeName(key).toLowerCase();
+        if (candidates.includes(normalizedKey)) {
+            if ('rel' !== selectedKey || 'canonical' !== String(selectedValue).toLowerCase()) {
+                if ('rel' !== normalizedKey || 'stylesheet' !== String(value).toLowerCase()) {
+                    selectedKey = normalizedKey;
+                    selectedValue = value;
+                }
+            }
+        }
+    }
+    if (void 0 === selectedKey || !selectedValue) return;
+    return {
+        key: selectedKey,
+        value: String(selectedValue).toLowerCase()
+    };
+};
+const dedupeTags = (tagName, records)=>{
+    const approvedValues = new Map();
+    const approved = [];
+    for(let index = records.length - 1; index >= 0; index -= 1){
+        const instanceValues = new Map();
+        const kept = [];
+        for (const tag of records[index][tagName]){
+            const primary = getPrimaryAttribute(tagName, tag);
+            if (void 0 === primary || approvedValues.get(primary.key)?.has(primary.value)) continue;
+            const seen = instanceValues.get(primary.key) ?? new Set();
+            seen.add(primary.value);
+            instanceValues.set(primary.key, seen);
+            kept.push(tag);
+        }
+        approved.unshift(...kept);
+        for (const [key, values] of instanceValues){
+            const target = approvedValues.get(key);
+            if (void 0 === target) approvedValues.set(key, values);
+            else for (const value of values)target.add(value);
+        }
+    }
+    return approved;
+};
+const deriveHelmetServerState = (react, records)=>{
+    const priority = createPriorityHeadDatum(react, records, dedupeTags);
+    return {
+        base: createDatum(react, 'base', deriveBaseTags(records)),
+        bodyAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.bodyAttributes)),
+        htmlAttributes: createAttributeDatum(mergeRecordAttributes(records, (record)=>record.htmlAttributes)),
+        link: createDatum(react, 'link', dedupeTags('link', records)),
+        meta: createDatum(react, 'meta', dedupeTags('meta', records)),
+        noscript: createDatum(react, "noscript", dedupeTags("noscript", records)),
+        priority,
+        script: createDatum(react, "script", dedupeTags("script", records)),
+        style: createDatum(react, 'style', dedupeTags('style', records)),
+        title: createTitleDatum(react, deriveTitle(records), mergeRecordAttributes(records, (record)=>record.titleAttributes))
+    };
+};
+const collectImmediateHelmetState = (react, context, record)=>{
+    const records = immediateRecords.get(context) ?? [];
+    if (!immediateRecords.has(context)) immediateRecords.set(context, records);
+    records.push(record);
+    return deriveHelmetServerState(react, records);
+};
+export { collectImmediateHelmetState, createHelmetRecord, createPriorityHeadDatum, deriveHelmetServerState, headTagsToComponents, headTitleToComponent, isPriorityHeadTag, markPriorityHeadRecord, renderHeadMarker };

package/dist/esm/html.mjs

@@ -0,0 +1,4 @@
+const SAFE_HTML_ATTRIBUTE_NAME = /^[^\u0000-\u0020"'<>/=]+$/u;
+const isSafeHtmlAttributeName = (name)=>SAFE_HTML_ATTRIBUTE_NAME.test(name);
+const escapeHtmlAttribute = (value)=>String(value).replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+export { escapeHtmlAttribute, isSafeHtmlAttributeName };

package/dist/esm/index.mjs

@@ -0,0 +1,4 @@
+export * from "./html.mjs";
+export * from "./navigationWarmup.mjs";
+export * from "./rendererHead.mjs";
+export * from "./shellStream.mjs";

package/dist/esm/navigationWarmup.mjs

@@ -0,0 +1,21 @@
+const realmNamespaces = new WeakMap();
+let nextRealmNamespace = 0;
+function getNavigationWarmupCacheKey(runtimeContext, chunkLoader, publicPath, warmupKey) {
+    let loaderNamespaces = realmNamespaces.get(runtimeContext);
+    if (void 0 === loaderNamespaces) {
+        loaderNamespaces = new WeakMap();
+        realmNamespaces.set(runtimeContext, loaderNamespaces);
+    }
+    let publicPathNamespaces = loaderNamespaces.get(chunkLoader);
+    if (void 0 === publicPathNamespaces) {
+        publicPathNamespaces = new Map();
+        loaderNamespaces.set(chunkLoader, publicPathNamespaces);
+    }
+    let namespace = publicPathNamespaces.get(publicPath);
+    if (void 0 === namespace) {
+        namespace = `realm-${++nextRealmNamespace}`;
+        publicPathNamespaces.set(publicPath, namespace);
+    }
+    return `${namespace}:${warmupKey}`;
+}
+export { getNavigationWarmupCacheKey };

package/dist/esm/node.mjs

@@ -0,0 +1,61 @@
+import { Transform, pipeline } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { abortHeadRender, createHeadChunkProcessor } from "./rendererHead.mjs";
+export * from "./rendererHead.mjs";
+const toError = (reason)=>reason instanceof Error ? reason : new Error(String(reason));
+const createNodeHeadMarkerStripper = (context, terminalMarker)=>{
+    const decoder = new StringDecoder('utf8');
+    const processor = createHeadChunkProcessor(context);
+    let terminalCarry = '';
+    let sawTerminalMarker = void 0 === terminalMarker;
+    const observeTerminalMarker = (output)=>{
+        if (!sawTerminalMarker && void 0 !== terminalMarker) {
+            const observed = terminalCarry + output;
+            sawTerminalMarker = observed.includes(terminalMarker);
+            terminalCarry = observed.slice(Math.max(0, observed.length - terminalMarker.length + 1));
+        }
+        return output;
+    };
+    return new Transform({
+        transform (chunk, _encoding, callback) {
+            try {
+                callback(null, observeTerminalMarker(processor.push(decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))));
+            } catch (error) {
+                callback(toError(error));
+            }
+        },
+        flush (callback) {
+            try {
+                const output = observeTerminalMarker(processor.finish(decoder.end()));
+                callback(null, sawTerminalMarker ? output : `${output}${terminalMarker}`);
+            } catch (error) {
+                callback(toError(error));
+            }
+        },
+        destroy (error, callback) {
+            try {
+                abortHeadRender(context);
+                callback(error);
+            } catch (abortError) {
+                callback(error ?? toError(abortError));
+            }
+        }
+    });
+};
+const createOnceErrorReporter = (onError)=>{
+    let reported = false;
+    return (error)=>{
+        if (!reported) {
+            reported = true;
+            onError?.(error);
+        }
+    };
+};
+const pipeNodeHeadStream = (options)=>{
+    const { source, destination, context, terminalMarker, onError } = options;
+    const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
+    pipeline(source, stripper, destination, (error)=>{
+        if (null !== error) onError?.(error);
+    });
+};
+export { createNodeHeadMarkerStripper, createOnceErrorReporter, pipeNodeHeadStream };

package/dist/esm/rendererHead.mjs

@@ -0,0 +1,162 @@
+export * from "./helmetCompat.mjs";
+const MARKER_ATTRIBUTE = 'data-modern-helmet';
+const MARKER_PREFIX = `<template ${MARKER_ATTRIBUTE}="`;
+const MARKER_SUFFIX = '"></template>';
+const RECORD_ID_WIDTH = 12;
+const MARKER_LENGTH = MARKER_PREFIX.length + 1 + 36 + RECORD_ID_WIDTH + MARKER_SUFFIX.length;
+const HEAD_STATE = Symbol('modern.rendererHead');
+const getState = (context)=>{
+    const headContext = context;
+    let state = headContext[HEAD_STATE];
+    if (void 0 === state) {
+        state = {
+            publishedRecords: []
+        };
+        Object.defineProperty(headContext, HEAD_STATE, {
+            value: state
+        });
+    }
+    return state;
+};
+const formatId = (value)=>value.toString(36).padStart(RECORD_ID_WIDTH, '0');
+const createToken = (transaction)=>{
+    const token = `h${transaction.nonce}${formatId(transaction.nextRecordId)}`;
+    transaction.nextRecordId += 1;
+    return token;
+};
+const beginHeadRender = (context)=>{
+    const state = getState(context);
+    state.transaction = {
+        recordsByToken: new Map(),
+        committedRecords: [],
+        committedTokens: new Set(),
+        nextRecordId: 0,
+        nonce: globalThis.crypto.randomUUID(),
+        previousRecords: state.publishedRecords,
+        sealed: false
+    };
+    state.publish?.([]);
+};
+const collectHeadRecord = (context, createRecord, publish)=>{
+    const state = getState(context);
+    const transaction = state.transaction;
+    if (void 0 === transaction) return;
+    const hadPublisher = void 0 !== state.publish;
+    state.publish = (records)=>publish(records);
+    if (!hadPublisher) state.publish([]);
+    if (transaction.sealed) return null;
+    const token = createToken(transaction);
+    transaction.recordsByToken.set(token, createRecord());
+    return {
+        [MARKER_ATTRIBUTE]: token
+    };
+};
+const collectHeadState = (context, createRecord, derive, target)=>collectHeadRecord(context, createRecord, (records)=>{
+        target.helmet = derive(records);
+    });
+const consumeMarkers = (context, html)=>{
+    const transaction = getState(context).transaction;
+    if (void 0 === transaction) return html;
+    let cursor = 0;
+    let stripped = '';
+    while(cursor < html.length){
+        const start = html.indexOf(MARKER_PREFIX, cursor);
+        if (-1 === start) {
+            stripped += html.slice(cursor);
+            break;
+        }
+        const tokenStart = start + MARKER_PREFIX.length;
+        const end = html.indexOf(MARKER_SUFFIX, tokenStart);
+        if (-1 === end) {
+            stripped += html.slice(cursor);
+            break;
+        }
+        const token = html.slice(tokenStart, end);
+        if (transaction.recordsByToken.has(token)) {
+            stripped += html.slice(cursor, start);
+            if (!transaction.sealed && !transaction.committedTokens.has(token)) {
+                transaction.committedTokens.add(token);
+                transaction.committedRecords.push(transaction.recordsByToken.get(token));
+            }
+        } else stripped += html.slice(cursor, end + MARKER_SUFFIX.length);
+        cursor = end + MARKER_SUFFIX.length;
+    }
+    return stripped;
+};
+const rendererHead_publish = (context)=>{
+    const state = getState(context);
+    const records = state.transaction?.committedRecords ?? [];
+    state.publishedRecords = records;
+    state.publish?.(records);
+};
+const publishHeadRender = (context)=>{
+    const transaction = getState(context).transaction;
+    if (void 0 !== transaction) {
+        transaction.sealed = true;
+        rendererHead_publish(context);
+    }
+};
+const finishHeadRender = (context)=>{
+    const state = getState(context);
+    if (void 0 !== state.transaction) {
+        if (!state.transaction.sealed) rendererHead_publish(context);
+        state.transaction = void 0;
+    }
+};
+const completeHeadRender = (context, html)=>{
+    const stripped = consumeMarkers(context, html);
+    finishHeadRender(context);
+    return stripped;
+};
+const abortHeadRender = (context)=>{
+    const state = getState(context);
+    const transaction = state.transaction;
+    if (void 0 !== transaction) {
+        state.publishedRecords = transaction.previousRecords;
+        state.publish?.(transaction.previousRecords);
+        state.transaction = void 0;
+    }
+};
+const findCarryStart = (input)=>{
+    const windowStart = Math.max(0, input.length - MARKER_LENGTH + 1);
+    const markerStart = input.lastIndexOf(MARKER_PREFIX);
+    if (markerStart >= windowStart && input.length - markerStart < MARKER_LENGTH) return markerStart;
+    const maxPrefixLength = Math.min(MARKER_PREFIX.length - 1, input.length);
+    for(let length = maxPrefixLength; length > 0; length -= 1)if (MARKER_PREFIX.startsWith(input.slice(-length))) return input.length - length;
+    return input.length;
+};
+const createHeadChunkProcessor = (context)=>{
+    let carry = '';
+    return {
+        push (chunk) {
+            const input = carry + chunk;
+            const carryStart = findCarryStart(input);
+            const output = consumeMarkers(context, input.slice(0, carryStart));
+            carry = input.slice(carryStart);
+            return output;
+        },
+        finish (chunk = '') {
+            const output = completeHeadRender(context, carry + chunk);
+            carry = '';
+            return output;
+        }
+    };
+};
+const createWebHeadMarkerStripper = (context)=>{
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const processor = createHeadChunkProcessor(context);
+    return new TransformStream({
+        transform (chunk, controller) {
+            const output = processor.push(decoder.decode(chunk, {
+                stream: true
+            }));
+            if (output) controller.enqueue(encoder.encode(output));
+        },
+        flush (controller) {
+            const output = processor.finish(decoder.decode());
+            if (output) controller.enqueue(encoder.encode(output));
+        }
+    });
+};
+export { abortHeadRender, beginHeadRender, collectHeadRecord, collectHeadState, completeHeadRender, createHeadChunkProcessor, createWebHeadMarkerStripper, finishHeadRender, publishHeadRender };