@lwc/ssr-runtime 8.3.0 → 8.5.0

package/dist/index.cjs.js

@@ -5,8 +5,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var shared = require('@lwc/shared');
-
 /*
  * Copyright (c) 2024, Salesforce, Inc.
  * All rights reserved.
@@ -118,6 +116,238 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+/**
+ * Copyright (c) 2024 Salesforce, Inc.
+ */
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ *
+ * @param value
+ * @param msg
+ */
+
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const { 
+/** Detached {@linkcode Object.assign}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign MDN Reference}. */
+assign, 
+/** Detached {@linkcode Object.create}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create MDN Reference}. */
+create, 
+/** Detached {@linkcode Object.defineProperties}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties MDN Reference}. */
+defineProperties, 
+/** Detached {@linkcode Object.defineProperty}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty MDN Reference}. */
+defineProperty, 
+/** Detached {@linkcode Object.entries}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries MDN Reference}. */
+entries, 
+/** Detached {@linkcode Object.freeze}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze MDN Reference}. */
+freeze, 
+/** Detached {@linkcode Object.fromEntries}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries MDN Reference}. */
+fromEntries, 
+/** Detached {@linkcode Object.getOwnPropertyDescriptor}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor MDN Reference}. */
+getOwnPropertyDescriptor, 
+/** Detached {@linkcode Object.getOwnPropertyDescriptors}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors MDN Reference}. */
+getOwnPropertyDescriptors, 
+/** Detached {@linkcode Object.getOwnPropertyNames}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames MDN Reference}. */
+getOwnPropertyNames, 
+/** Detached {@linkcode Object.getOwnPropertySymbols}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols MDN Reference}. */
+getOwnPropertySymbols, 
+/** Detached {@linkcode Object.getPrototypeOf}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf MDN Reference}. */
+getPrototypeOf, 
+/** Detached {@linkcode Object.hasOwnProperty}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty MDN Reference}. */
+hasOwnProperty, 
+/** Detached {@linkcode Object.isFrozen}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen MDN Reference}. */
+isFrozen, 
+/** Detached {@linkcode Object.keys}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys MDN Reference}. */
+keys, 
+/** Detached {@linkcode Object.seal}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal MDN Reference}. */
+seal, 
+/** Detached {@linkcode Object.setPrototypeOf}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf MDN Reference}. */
+setPrototypeOf, } = Object;
+const { 
+/** Detached {@linkcode Array.isArray}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray MDN Reference}. */
+isArray, 
+/** Detached {@linkcode Array.from}; see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from MDN Reference}. */
+from: ArrayFrom, } = Array;
+// For some reason, JSDoc don't get picked up for multiple renamed destructured constants (even
+// though it works fine for one, e.g. isArray), so comments for these are added to the export
+// statement, rather than this declaration.
+const { concat: ArrayConcat, copyWithin: ArrayCopyWithin, every: ArrayEvery, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, findIndex: ArrayFindIndex, includes: ArrayIncludes, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, // Weird anomaly!
+ } = Array.prototype;
+// No JSDocs here - see comment for Array.prototype
+const { charAt: StringCharAt, charCodeAt: StringCharCodeAt, replace: StringReplace, split: StringSplit, slice: StringSlice, toLowerCase: StringToLowerCase, trim: StringTrim, } = String.prototype;
+/**
+ * Determines whether the argument is `null`.
+ * @param obj Value to test
+ * @returns `true` if the value is `null`.
+ */
+function isNull(obj) {
+    return obj === null;
+}
+const OtS = {}.toString;
+/**
+ * Converts the argument to a string, safely accounting for objects with "null" prototype.
+ * Note that `toString(null)` returns `"[object Null]"` rather than `"null"`.
+ * @param obj Value to convert to a string.
+ * @returns String representation of the value.
+ */
+function toString(obj) {
+    if (obj?.toString) {
+        // Arrays might hold objects with "null" prototype So using
+        // Array.prototype.toString directly will cause an error Iterate through
+        // all the items and handle individually.
+        if (isArray(obj)) {
+            // This behavior is slightly different from Array#toString:
+            // 1. Array#toString calls `this.join`, rather than Array#join
+            // Ex: arr = []; arr.join = () => 1; arr.toString() === 1; toString(arr) === ''
+            // 2. Array#toString delegates to Object#toString if `this.join` is not a function
+            // Ex: arr = []; arr.join = 'no'; arr.toString() === '[object Array]; toString(arr) = ''
+            // 3. Array#toString converts null/undefined to ''
+            // Ex: arr = [null, undefined]; arr.toString() === ','; toString(arr) === '[object Null],undefined'
+            // 4. Array#toString converts recursive references to arrays to ''
+            // Ex: arr = [1]; arr.push(arr, 2); arr.toString() === '1,,2'; toString(arr) throws
+            // Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString
+            return ArrayJoin.call(ArrayMap.call(obj, toString), ',');
+        }
+        return obj.toString();
+    }
+    else if (typeof obj === 'object') {
+        // This catches null and returns "[object Null]". Weird, but kept for backwards compatibility.
+        return OtS.call(obj);
+    }
+    else {
+        return String(obj);
+    }
+}
+
+/*
+ * Copyright (c) 2018, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * According to the following list, there are 48 aria attributes of which two (ariaDropEffect and
+ * ariaGrabbed) are deprecated:
+ * https://www.w3.org/TR/wai-aria-1.1/#x6-6-definitions-of-states-and-properties-all-aria-attributes
+ *
+ * The above list of 46 aria attributes is consistent with the following resources:
+ * https://github.com/w3c/aria/pull/708/files#diff-eacf331f0ffc35d4b482f1d15a887d3bR11060
+ * https://wicg.github.io/aom/spec/aria-reflection.html
+ *
+ * NOTE: If you update this list, please update test files that implicitly reference this list!
+ * Searching the codebase for `aria-flowto` and `ariaFlowTo` should be good enough to find all usages.
+ */
+const AriaPropertyNames = [
+    'ariaActiveDescendant',
+    'ariaAtomic',
+    'ariaAutoComplete',
+    'ariaBusy',
+    'ariaChecked',
+    'ariaColCount',
+    'ariaColIndex',
+    'ariaColIndexText',
+    'ariaColSpan',
+    'ariaControls',
+    'ariaCurrent',
+    'ariaDescribedBy',
+    'ariaDescription',
+    'ariaDetails',
+    'ariaDisabled',
+    'ariaErrorMessage',
+    'ariaExpanded',
+    'ariaFlowTo',
+    'ariaHasPopup',
+    'ariaHidden',
+    'ariaInvalid',
+    'ariaKeyShortcuts',
+    'ariaLabel',
+    'ariaLabelledBy',
+    'ariaLevel',
+    'ariaLive',
+    'ariaModal',
+    'ariaMultiLine',
+    'ariaMultiSelectable',
+    'ariaOrientation',
+    'ariaOwns',
+    'ariaPlaceholder',
+    'ariaPosInSet',
+    'ariaPressed',
+    'ariaReadOnly',
+    'ariaRelevant',
+    'ariaRequired',
+    'ariaRoleDescription',
+    'ariaRowCount',
+    'ariaRowIndex',
+    'ariaRowIndexText',
+    'ariaRowSpan',
+    'ariaSelected',
+    'ariaSetSize',
+    'ariaSort',
+    'ariaValueMax',
+    'ariaValueMin',
+    'ariaValueNow',
+    'ariaValueText',
+    'ariaBrailleLabel',
+    'ariaBrailleRoleDescription',
+    'role',
+];
+const { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap } = /*@__PURE__*/ (() => {
+    const AriaAttrNameToPropNameMap = create(null);
+    const AriaPropNameToAttrNameMap = create(null);
+    // Synthetic creation of all AOM property descriptors for Custom Elements
+    forEach.call(AriaPropertyNames, (propName) => {
+        const attrName = StringToLowerCase.call(StringReplace.call(propName, /^aria/, () => 'aria-'));
+        AriaAttrNameToPropNameMap[attrName] = propName;
+        AriaPropNameToAttrNameMap[propName] = attrName;
+    });
+    return { AriaAttrNameToPropNameMap, AriaPropNameToAttrNameMap };
+})();
+
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const ESCAPED_CHARS = {
+    '"': '"',
+    "'": ''',
+    '<': '&lt;',
+    '>': '&gt;',
+    '&': '&amp;',
+};
+/**
+ *
+ * @param str
+ * @param attrMode
+ */
+function htmlEscape(str, attrMode = false) {
+    const searchValue = attrMode ? /["&]/g : /["'<>&]/g;
+    return str.replace(searchValue, (char) => ESCAPED_CHARS[char]);
+}
+function flattenStylesheets(stylesheets) {
+    const list = [];
+    for (const stylesheet of stylesheets) {
+        if (!isArray(stylesheet)) {
+            list.push(stylesheet);
+        }
+        else {
+            list.push(...flattenStylesheets(stylesheet));
+        }
+    }
+    return list;
+}
+/** version: 8.5.0 */
+
 /*
  * Copyright (c) 2024, Salesforce, Inc.
  * All rights reserved.
@@ -159,41 +389,169 @@ class MutationTracker {
 _MutationTracker_enabledSet = new WeakMap(), _MutationTracker_mutationMap = new WeakMap();
 const mutationTracker = new MutationTracker();
 
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+/**
+ * Map of global attribute or ARIA attribute to the corresponding property name.
+ * Not all global attributes are included, just those from `HTMLElementTheGoodParts`.
+ */
+const attrsToProps = assign(create(null), {
+    accesskey: 'accessKey',
+    dir: 'dir',
+    draggable: 'draggable',
+    hidden: 'hidden',
+    id: 'id',
+    lang: 'lang',
+    spellcheck: 'spellcheck',
+    tabindex: 'tabIndex',
+    title: 'title',
+    ...AriaAttrNameToPropNameMap,
+});
+/**
+ * Descriptor for IDL attribute reflections that merely reflect the string, e.g. `title`.
+ */
+const stringDescriptor = (attrName) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        return this.getAttribute(attrName);
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute(attrName);
+        const normalizedValue = String(newValue);
+        if (normalizedValue !== currentValue) {
+            this.setAttribute(attrName, normalizedValue);
+        }
+    },
+});
+/** Descriptor for a boolean that checks for `attr="true"` or `attr="false"`, e.g. `spellcheck` and `draggable`. */
+const explicitBooleanDescriptor = (attrName, defaultValue) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        const value = this.getAttribute(attrName);
+        return value === null ? defaultValue : value === String(defaultValue);
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute(attrName);
+        const normalizedValue = String(Boolean(newValue));
+        if (normalizedValue !== currentValue) {
+            this.setAttribute(attrName, normalizedValue);
+        }
+    },
+});
+/**
+ * Descriptor for a "true" boolean attribute that checks solely for presence, e.g. `hidden`.
+ */
+const booleanAttributeDescriptor = (attrName) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        return this.hasAttribute(attrName);
+    },
+    set(newValue) {
+        const hasAttribute = this.hasAttribute(attrName);
+        if (newValue) {
+            if (!hasAttribute) {
+                this.setAttribute(attrName, '');
+            }
+        }
+        else {
+            if (hasAttribute) {
+                this.removeAttribute(attrName);
+            }
+        }
+    },
+});
+/**
+ * Descriptor for ARIA reflections, e.g. `ariaLabel` and `role`.
+ */
+const ariaDescriptor = (attrName) => ({
+    configurable: true,
+    enumerable: true,
+    get() {
+        return this.getAttribute(attrName);
+    },
+    set(newValue) {
+        const currentValue = this.getAttribute(attrName);
+        if (newValue !== currentValue) {
+            // TODO [#3284]: According to the spec, IDL nullable type values
+            // (null and undefined) should remove the attribute; however, we
+            // only do so in the case of null for historical reasons.
+            if (isNull(newValue)) {
+                this.removeAttribute(attrName);
+            }
+            else {
+                this.setAttribute(attrName, toString(newValue));
+            }
+        }
+    },
+});
+function reflectAttrToProp(instance, attrName, attrValue) {
+    const reflectedPropName = attrsToProps[attrName];
+    // If it is a reflected property and it was not overridden by the instance
+    if (reflectedPropName && !hasOwnProperty.call(instance, reflectedPropName)) {
+        const currentValue = instance[reflectedPropName];
+        if (currentValue !== attrValue) {
+            instance[reflectedPropName] = attrValue;
+        }
+    }
+}
+const descriptors = {
+    accessKey: stringDescriptor('accesskey'),
+    dir: stringDescriptor('dir'),
+    draggable: explicitBooleanDescriptor('draggable', true),
+    hidden: booleanAttributeDescriptor('hidden'),
+    id: stringDescriptor('id'),
+    lang: stringDescriptor('lang'),
+    spellcheck: explicitBooleanDescriptor('spellcheck', false),
+    tabIndex: {
+        get() {
+            const str = this.getAttribute('tabindex');
+            const num = Number(str);
+            return isFinite(num) ? Math.trunc(num) : -1;
+        },
+        set(newValue) {
+            const currentValue = this.getAttribute('tabindex');
+            const num = Number(newValue);
+            const normalizedValue = isFinite(num) ? String(Math.trunc(num)) : '0';
+            if (normalizedValue !== currentValue) {
+                this.setAttribute('tabindex', toString(newValue));
+            }
+        },
+    },
+    title: stringDescriptor('title'),
+};
+// Add descriptors for ARIA attributes
+for (const [attrName, propName] of entries(AriaAttrNameToPropNameMap)) {
+    descriptors[propName] = ariaDescriptor(attrName);
+}
+
 /*
  * Copyright (c) 2024, salesforce.com, inc.
  * All rights reserved.
  * SPDX-License-Identifier: MIT
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
-var _LightningElement_instances, _LightningElement_attrs, _LightningElement_classList, _LightningElement_setAttribute;
+var _LightningElement_attrs, _LightningElement_classList;
 const SYMBOL__SET_INTERNALS = Symbol('set-internals');
+const SYMBOL__GENERATE_MARKUP = Symbol('generate-markup');
 class LightningElement {
     constructor(propsAvailableAtConstruction) {
-        _LightningElement_instances.add(this);
         this.isConnected = false;
         this.className = '';
         _LightningElement_attrs.set(this, void 0);
         _LightningElement_classList.set(this, null);
-        Object.assign(this, propsAvailableAtConstruction);
+        assign(this, propsAvailableAtConstruction);
     }
-    [(_LightningElement_attrs = new WeakMap(), _LightningElement_classList = new WeakMap(), _LightningElement_instances = new WeakSet(), SYMBOL__SET_INTERNALS)](props, reflectedProps, attrs) {
-        Object.assign(this, props);
+    [(_LightningElement_attrs = new WeakMap(), _LightningElement_classList = new WeakMap(), SYMBOL__SET_INTERNALS)](props, attrs) {
         __classPrivateFieldSet(this, _LightningElement_attrs, attrs, "f");
-        // Whenever a reflected prop changes, we'll update the original props object
-        // that was passed in. That'll be referenced when the attrs are rendered later.
-        for (const reflectedPropName of reflectedProps) {
-            Object.defineProperty(this, reflectedPropName, {
-                get() {
-                    return props[reflectedPropName] ?? null;
-                },
-                set(newValue) {
-                    props[reflectedPropName] = newValue;
-                    mutationTracker.add(this, shared.htmlPropertyToAttribute(reflectedPropName));
-                },
-                enumerable: true,
-            });
-        }
-        Object.defineProperty(this, 'className', {
+        assign(this, props);
+        defineProperty(this, 'className', {
             get() {
                 return props.class ?? '';
             },
@@ -211,29 +569,29 @@ class LightningElement {
         return (__classPrivateFieldSet(this, _LightningElement_classList, new ClassList(this), "f"));
     }
     setAttribute(attrName, attrValue) {
-        __classPrivateFieldGet(this, _LightningElement_instances, "m", _LightningElement_setAttribute).call(this, attrName, String(attrValue));
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        const normalizedValue = String(attrValue);
+        __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName] = normalizedValue;
+        reflectAttrToProp(this, normalizedName, normalizedValue);
+        mutationTracker.add(this, normalizedName);
     }
     getAttribute(attrName) {
-        if (this.hasAttribute(attrName)) {
-            return __classPrivateFieldGet(this, _LightningElement_attrs, "f")[attrName];
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        if (hasOwnProperty.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName)) {
+            return __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
         }
         return null;
     }
     hasAttribute(attrName) {
-        return typeof attrName === 'string' && typeof __classPrivateFieldGet(this, _LightningElement_attrs, "f")[attrName] === 'string';
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        return hasOwnProperty.call(__classPrivateFieldGet(this, _LightningElement_attrs, "f"), normalizedName);
     }
     removeAttribute(attrName) {
-        if (this.hasAttribute(attrName)) {
-            // Reflected attributes use accessor methods to update their
-            // corresponding properties so we can't simply `delete`. Instead,
-            // we use `null` when we want to remove.
-            __classPrivateFieldGet(this, _LightningElement_instances, "m", _LightningElement_setAttribute).call(this, attrName, null);
-        }
-        else {
-            // This interprets the removal of a non-existing attribute as an
-            // attribute mutation. We may want to revisit this.
-            mutationTracker.add(this, attrName);
-        }
+        const normalizedName = StringToLowerCase.call(toString(attrName));
+        delete __classPrivateFieldGet(this, _LightningElement_attrs, "f")[normalizedName];
+        reflectAttrToProp(this, normalizedName, null);
+        // Track mutations for removal of non-existing attributes
+        mutationTracker.add(this, normalizedName);
     }
     addEventListener(_type, _listener, _options) {
         // noop
@@ -309,10 +667,7 @@ class LightningElement {
         throw new Error('Method "setAttributeNS" not implemented.');
     }
 }
-_LightningElement_setAttribute = function _LightningElement_setAttribute(attrName, attrValue) {
-    __classPrivateFieldGet(this, _LightningElement_attrs, "f")[attrName] = attrValue;
-    mutationTracker.add(this, attrName);
-};
+defineProperties(LightningElement.prototype, descriptors);
 
 /*
  * Copyright (c) 2024, salesforce.com, inc.
@@ -336,15 +691,54 @@ function* renderAttrs(instance, attrs) {
     }
     yield mutationTracker.renderMutatedAttrs(instance);
 }
+function renderAttrsNoYield(emit, instance, attrs) {
+    if (!attrs) {
+        return;
+    }
+    for (const attrName of Object.getOwnPropertyNames(attrs)) {
+        const attrVal = attrs[attrName];
+        if (typeof attrVal === 'string') {
+            emit(attrVal === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrVal)}"`);
+        }
+        else if (attrVal === null) {
+            emit('');
+        }
+    }
+    emit(mutationTracker.renderMutatedAttrs(instance));
+}
 function* fallbackTmpl(_props, _attrs, _slotted, Cmp, _instance) {
     if (Cmp.renderMode !== 'light') {
         yield '<template shadowrootmode="open"></template>';
     }
 }
-async function serverSideRenderComponent(tagName, compiledGenerateMarkup, props) {
+function fallbackTmplNoYield(emit, _props, _attrs, _slotted, Cmp, _instance) {
+    if (Cmp.renderMode !== 'light') {
+        emit('<template shadowrootmode="open"></template>');
+    }
+}
+async function serverSideRenderComponent(tagName, Component, props = {}, mode = 'asyncYield') {
+    if (typeof tagName !== 'string') {
+        throw new Error(`tagName must be a string, found: ${tagName}`);
+    }
+    // TODO [#4726]: remove `generateMarkup` export
+    const generateMarkup = SYMBOL__GENERATE_MARKUP in Component ? Component[SYMBOL__GENERATE_MARKUP] : Component;
     let markup = '';
-    for await (const segment of compiledGenerateMarkup(tagName, props, null, null)) {
+    const emit = (segment) => {
         markup += segment;
+    };
+    if (mode === 'asyncYield') {
+        for await (const segment of generateMarkup(tagName, props, null, null)) {
+            markup += segment;
+        }
+    }
+    else if (mode === 'async') {
+        await generateMarkup(emit, tagName, props, null, null);
+    }
+    else if (mode === 'sync') {
+        generateMarkup(emit, tagName, props, null, null);
+    }
+    else {
+        throw new Error(`Invalid mode: ${mode}`);
     }
     return markup;
 }
@@ -655,16 +1049,50 @@ function validateStyleTextContents(contents) {
     }
 }
 
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+function hasScopedStaticStylesheets(Component) {
+    const { stylesheets } = Component;
+    if (stylesheets) {
+        return flattenStylesheets(stylesheets).some((stylesheet) => stylesheet.$scoped$);
+    }
+    return false;
+}
+function renderStylesheets(stylesheets, scopeToken, Component, hasScopedTemplateStyles) {
+    const hasAnyScopedStyles = hasScopedTemplateStyles || hasScopedStaticStylesheets(Component);
+    let result = '';
+    const truthyStylesheets = stylesheets.filter(Boolean);
+    for (const stylesheet of flattenStylesheets(truthyStylesheets)) {
+        // TODO [#2869]: `<style>`s should not have scope token classes
+        result += `<style${hasAnyScopedStyles ? ` class="${scopeToken}"` : ''} type="text/css">`;
+        const token = stylesheet.$scoped$ ? scopeToken : undefined;
+        const useActualHostSelector = !stylesheet.$scoped$ || Component.renderMode !== 'light';
+        const useNativeDirPseudoclass = true;
+        const styleContents = stylesheet(token, useActualHostSelector, useNativeDirPseudoclass);
+        validateStyleTextContents(styleContents);
+        result += styleContents + '</style>';
+    }
+    return result;
+}
+
 exports.ClassList = ClassList;
 exports.LightningElement = LightningElement;
+exports.SYMBOL__GENERATE_MARKUP = SYMBOL__GENERATE_MARKUP;
 exports.SYMBOL__SET_INTERNALS = SYMBOL__SET_INTERNALS;
 exports.api = api;
 exports.createContextProvider = createContextProvider;
 exports.createElement = createElement;
 exports.fallbackTmpl = fallbackTmpl;
+exports.fallbackTmplNoYield = fallbackTmplNoYield;
 exports.freezeTemplate = freezeTemplate;
 exports.getComponentDef = getComponentDef;
+exports.hasScopedStaticStylesheets = hasScopedStaticStylesheets;
 exports.hot = hot;
+exports.htmlEscape = htmlEscape;
 exports.isComponentConstructor = isComponentConstructor;
 exports.mutationTracker = mutationTracker;
 exports.parseFragment = parseFragment;
@@ -674,7 +1102,9 @@ exports.registerComponent = registerComponent;
 exports.registerDecorators = registerDecorators;
 exports.registerTemplate = registerTemplate;
 exports.renderAttrs = renderAttrs;
+exports.renderAttrsNoYield = renderAttrsNoYield;
 exports.renderComponent = serverSideRenderComponent;
+exports.renderStylesheets = renderStylesheets;
 exports.renderer = renderer;
 exports.sanitizeAttribute = sanitizeAttribute;
 exports.serverSideRenderComponent = serverSideRenderComponent;
@@ -689,5 +1119,5 @@ exports.track = track;
 exports.unwrap = unwrap;
 exports.validateStyleTextContents = validateStyleTextContents;
 exports.wire = wire;
-/** version: 8.3.0 */
+/** version: 8.5.0 */
 //# sourceMappingURL=index.cjs.js.map