@lwc/ssr-runtime 8.1.3 → 8.3.0

package/dist/index.js

@@ -1,67 +1,14 @@
 /**
  * Copyright (c) 2024 Salesforce, Inc.
  */
-/*
- * 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
- */
-/**
- * Per the HTML spec on restrictions for "raw text elements" like `<style>`:
- *
- * > The text in raw text and escapable raw text elements must not contain any occurrences of the string
- * > "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS) followed by characters that case-insensitively match the tag name of
- * > the element followed by one of:
- * > - U+0009 CHARACTER TABULATION (tab)
- * > - U+000A LINE FEED (LF)
- * > - U+000C FORM FEED (FF)
- * > - U+000D CARRIAGE RETURN (CR)
- * > - U+0020 SPACE
- * > - U+003E GREATER-THAN SIGN (>), or
- * > - U+002F SOLIDUS (/)
- * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
- */
-const INVALID_STYLE_CONTENT = /<\/style[\t\n\f\r >/]/i;
-/**
- * The text content inside `<style>` is a special case. It is _only_ rendered by the LWC engine itself; `<style>` tags
- * are disallowed inside of HTML templates.
- *
- * The `<style>` tag is unusual in how it's defined in HTML. Like `<script>`, it is considered a "raw text element,"
- * which means that it is parsed as raw text, but certain character sequences are disallowed, namely to avoid XSS
- * attacks like `</style><script>alert("pwned")</script>`.
- *
- * This also means that we cannot use "normal" HTML escaping inside `<style>` tags, e.g. we cannot use `&lt;`,
- * `&gt;`, etc., because these are treated as-is by the HTML parser.
- *
- *
- * @param contents CSS source to validate
- * @throws Throws if the contents provided are not valid.
- * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
- * @see https://github.com/salesforce/lwc/issues/3439
- * @example
- * validateStyleTextContents('div { color: red }') // Ok
- * validateStyleTextContents('</style><script>alert("pwned")</script>') // Throws
- */
-function validateStyleTextContents(contents) {
-    if (INVALID_STYLE_CONTENT.test(contents)) {
-        throw new Error('CSS contains unsafe characters and cannot be serialized inside a style element');
-    }
-}
+import { htmlPropertyToAttribute } from '@lwc/shared';
 
 /*
- * Copyright (c) 2024, salesforce.com, inc.
+ * 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
  */
-// At runtime, we don't have access to the DOM, so we don't want TypeScript to allow accessing DOM
-// globals. However, we're mimicking DOM functionality here, so we *do* want access to DOM types.
-// To access the real DOM types when writing new code, uncomment the line below and comment out the
-// stub types. Switch them back when you're done to validate that you're not accidentally using
-// DOM globals. IMPORTANT: The comment below is a "triple slash directive", it must start with ///
-// and be located before import statements.
-// /// <reference lib="dom" />
 const MULTI_SPACE = /\s+/g;
 class ClassList {
     constructor(el) {
@@ -131,17 +78,103 @@ class ClassList {
         throw new Error('Property "length" not implemented.');
     }
 }
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/*
+ * 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
+ */
+var _MutationTracker_enabledSet, _MutationTracker_mutationMap;
+class MutationTracker {
+    constructor() {
+        _MutationTracker_enabledSet.set(this, new WeakSet());
+        _MutationTracker_mutationMap.set(this, new WeakMap());
+    }
+    add(instance, attrName) {
+        if (__classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").has(instance)) {
+            let mutatedAttrs = __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").get(instance);
+            if (!mutatedAttrs) {
+                mutatedAttrs = new Set();
+                __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").set(instance, mutatedAttrs);
+            }
+            mutatedAttrs.add(attrName.toLowerCase());
+        }
+    }
+    enable(instance) {
+        __classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").add(instance);
+    }
+    disable(instance) {
+        __classPrivateFieldGet(this, _MutationTracker_enabledSet, "f").delete(instance);
+    }
+    renderMutatedAttrs(instance) {
+        const mutatedAttrs = __classPrivateFieldGet(this, _MutationTracker_mutationMap, "f").get(instance);
+        if (mutatedAttrs) {
+            return ` data-lwc-host-mutated="${[...mutatedAttrs].sort().join(' ')}"`;
+        }
+        else {
+            return '';
+        }
+    }
+}
+_MutationTracker_enabledSet = new WeakMap(), _MutationTracker_mutationMap = new WeakMap();
+const mutationTracker = new MutationTracker();
+
+/*
+ * 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;
+const SYMBOL__SET_INTERNALS = Symbol('set-internals');
 class LightningElement {
     constructor(propsAvailableAtConstruction) {
+        _LightningElement_instances.add(this);
         this.isConnected = false;
         this.className = '';
-        this.__classList = null;
+        _LightningElement_attrs.set(this, void 0);
+        _LightningElement_classList.set(this, null);
         Object.assign(this, propsAvailableAtConstruction);
     }
-    // TODO [W-14977927]: protect internals from userland
-    __internal__setState(props, reflectedProps, attrs) {
+    [(_LightningElement_attrs = new WeakMap(), _LightningElement_classList = new WeakMap(), _LightningElement_instances = new WeakSet(), SYMBOL__SET_INTERNALS)](props, reflectedProps, attrs) {
         Object.assign(this, props);
-        this.__attrs = 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) {
@@ -151,6 +184,7 @@ class LightningElement {
                 },
                 set(newValue) {
                     props[reflectedPropName] = newValue;
+                    mutationTracker.add(this, htmlPropertyToAttribute(reflectedPropName));
                 },
                 enumerable: true,
             });
@@ -162,26 +196,40 @@ class LightningElement {
             set(newVal) {
                 props.class = newVal;
                 attrs.class = newVal;
+                mutationTracker.add(this, 'class');
             },
         });
     }
     get classList() {
-        if (this.__classList) {
-            return this.__classList;
+        if (__classPrivateFieldGet(this, _LightningElement_classList, "f")) {
+            return __classPrivateFieldGet(this, _LightningElement_classList, "f");
         }
-        return (this.__classList = new ClassList(this));
+        return (__classPrivateFieldSet(this, _LightningElement_classList, new ClassList(this), "f"));
     }
-    getAttribute(attrName) {
-        return this.__attrs[attrName] ?? null;
+    setAttribute(attrName, attrValue) {
+        __classPrivateFieldGet(this, _LightningElement_instances, "m", _LightningElement_setAttribute).call(this, attrName, String(attrValue));
     }
-    setAttribute(attrName, value) {
-        this.__attrs[attrName] = String(value);
+    getAttribute(attrName) {
+        if (this.hasAttribute(attrName)) {
+            return __classPrivateFieldGet(this, _LightningElement_attrs, "f")[attrName];
+        }
+        return null;
     }
     hasAttribute(attrName) {
-        return Boolean(this.__attrs && attrName in this.__attrs);
+        return typeof attrName === 'string' && typeof __classPrivateFieldGet(this, _LightningElement_attrs, "f")[attrName] === 'string';
     }
     removeAttribute(attrName) {
-        this.__attrs[attrName] = null;
+        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);
+        }
     }
     addEventListener(_type, _listener, _options) {
         // noop
@@ -257,19 +305,32 @@ 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);
+};
+
+/*
+ * 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
+ */
 const escapeAttrVal = (attrVal) => attrVal.replaceAll('&', '&amp;').replaceAll('"', '&quot;');
-function* renderAttrs(attrs) {
+function* renderAttrs(instance, attrs) {
     if (!attrs) {
         return;
     }
-    for (const [key, val] of Object.entries(attrs)) {
-        if (typeof val === 'string') {
-            yield val === '' ? ` ${key}` : ` ${key}="${escapeAttrVal(val)}"`;
+    for (const attrName of Object.getOwnPropertyNames(attrs)) {
+        const attrVal = attrs[attrName];
+        if (typeof attrVal === 'string') {
+            yield attrVal === '' ? ` ${attrName}` : ` ${attrName}="${escapeAttrVal(attrVal)}"`;
         }
-        else if (val === null) {
-            return '';
+        else if (attrVal === null) {
+            yield '';
         }
     }
+    yield mutationTracker.renderMutatedAttrs(instance);
 }
 function* fallbackTmpl(_props, _attrs, _slotted, Cmp, _instance) {
     if (Cmp.renderMode !== 'light') {
@@ -284,6 +345,312 @@ async function serverSideRenderComponent(tagName, compiledGenerateMarkup, props)
     return markup;
 }
 
-export { LightningElement, fallbackTmpl, renderAttrs, serverSideRenderComponent, validateStyleTextContents };
-/** version: 8.1.3 */
+/*
+ * 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
+ */
+// Stubs for all the un-implemented exports from @lwc/engine-server
+function api(..._) {
+    throw new Error('@api cannot be used in SSR context.');
+}
+function createContextProvider(..._) {
+    throw new Error('createContextProvider cannot be used in SSR context.');
+}
+function createElement(..._) {
+    throw new Error('createElement cannot be used in SSR context.');
+}
+function freezeTemplate(..._) {
+    throw new Error('freezeTemplate cannot be used in SSR context.');
+}
+function getComponentDef(..._) {
+    throw new Error('getComponentDef cannot be used in SSR context.');
+}
+function isComponentConstructor(..._) {
+    throw new Error('isComponentConstructor cannot be used in SSR context.');
+}
+function parseFragment(..._) {
+    throw new Error('parseFragment cannot be used in SSR context.');
+}
+function parseSVGFragment(..._) {
+    throw new Error('parseSVGFragment cannot be used in SSR context.');
+}
+function readonly(..._) {
+    throw new Error('readonly cannot be used in SSR context.');
+}
+function registerComponent(..._) {
+    throw new Error('registerComponent cannot be used in SSR context.');
+}
+function registerDecorators(..._) {
+    throw new Error('registerDecorators cannot be used in SSR context.');
+}
+function registerTemplate(..._) {
+    throw new Error('registerTemplate cannot be used in SSR context.');
+}
+function sanitizeAttribute(..._) {
+    throw new Error('sanitizeAttribute cannot be used in SSR context.');
+}
+function setFeatureFlag(..._) {
+    throw new Error('setFeatureFlag cannot be used in SSR context.');
+}
+function setFeatureFlagForTest(..._) {
+    throw new Error('setFeatureFlagForTest cannot be used in SSR context.');
+}
+function setHooks(..._) {
+    throw new Error('setHooks cannot be used in SSR context.');
+}
+function swapComponent(..._) {
+    throw new Error('swapComponent cannot be used in SSR context.');
+}
+function swapStyle(..._) {
+    throw new Error('swapStyle cannot be used in SSR context.');
+}
+function swapTemplate(..._) {
+    throw new Error('swapTemplate cannot be used in SSR context.');
+}
+function track(..._) {
+    throw new Error('@track cannot be used in SSR context.');
+}
+function unwrap(..._) {
+    throw new Error('unwrap cannot be used in SSR context.');
+}
+function wire(..._) {
+    throw new Error('@wire cannot be used in SSR context.');
+}
+const renderer = {
+    isSyntheticShadowDefined: false,
+    insert(..._) {
+        throw new Error('renderer.insert cannot be used in SSR context.');
+    },
+    remove(..._) {
+        throw new Error('renderer.remove cannot be used in SSR context.');
+    },
+    cloneNode(..._) {
+        throw new Error('renderer.cloneNode cannot be used in SSR context.');
+    },
+    createFragment(..._) {
+        throw new Error('renderer.createFragment cannot be used in SSR context.');
+    },
+    createElement(..._) {
+        throw new Error('renderer.createElement cannot be used in SSR context.');
+    },
+    createText(..._) {
+        throw new Error('renderer.createText cannot be used in SSR context.');
+    },
+    createComment(..._) {
+        throw new Error('renderer.createComment cannot be used in SSR context.');
+    },
+    createCustomElement(..._) {
+        throw new Error('renderer.createCustomElement cannot be used in SSR context.');
+    },
+    nextSibling(..._) {
+        throw new Error('renderer.nextSibling cannot be used in SSR context.');
+    },
+    previousSibling(..._) {
+        throw new Error('renderer.previousSibling cannot be used in SSR context.');
+    },
+    attachShadow(..._) {
+        throw new Error('renderer.attachShadow cannot be used in SSR context.');
+    },
+    getProperty(..._) {
+        throw new Error('renderer.getProperty cannot be used in SSR context.');
+    },
+    setProperty(..._) {
+        throw new Error('renderer.setProperty cannot be used in SSR context.');
+    },
+    setText(..._) {
+        throw new Error('renderer.setText cannot be used in SSR context.');
+    },
+    getAttribute(..._) {
+        throw new Error('renderer.getAttribute cannot be used in SSR context.');
+    },
+    setAttribute(..._) {
+        throw new Error('renderer.setAttribute cannot be used in SSR context.');
+    },
+    removeAttribute(..._) {
+        throw new Error('renderer.removeAttribute cannot be used in SSR context.');
+    },
+    addEventListener(..._) {
+        throw new Error('renderer.addEventListener cannot be used in SSR context.');
+    },
+    removeEventListener(..._) {
+        throw new Error('renderer.removeEventListener cannot be used in SSR context.');
+    },
+    dispatchEvent(..._) {
+        throw new Error('renderer.dispatchEvent cannot be used in SSR context.');
+    },
+    getClassList(..._) {
+        throw new Error('renderer.getClassList cannot be used in SSR context.');
+    },
+    setCSSStyleProperty(..._) {
+        throw new Error('renderer.setCSSStyleProperty cannot be used in SSR context.');
+    },
+    getBoundingClientRect(..._) {
+        throw new Error('renderer.getBoundingClientRect cannot be used in SSR context.');
+    },
+    querySelector(..._) {
+        throw new Error('renderer.querySelector cannot be used in SSR context.');
+    },
+    querySelectorAll(..._) {
+        throw new Error('renderer.querySelectorAll cannot be used in SSR context.');
+    },
+    getElementsByTagName(..._) {
+        throw new Error('renderer.getElementsByTagName cannot be used in SSR context.');
+    },
+    getElementsByClassName(..._) {
+        throw new Error('renderer.getElementsByClassName cannot be used in SSR context.');
+    },
+    getChildren(..._) {
+        throw new Error('renderer.getChildren cannot be used in SSR context.');
+    },
+    getChildNodes(..._) {
+        throw new Error('renderer.getChildNodes cannot be used in SSR context.');
+    },
+    getFirstChild(..._) {
+        throw new Error('renderer.getFirstChild cannot be used in SSR context.');
+    },
+    getFirstElementChild(..._) {
+        throw new Error('renderer.getFirstElementChild cannot be used in SSR context.');
+    },
+    getLastChild(..._) {
+        throw new Error('renderer.getLastChild cannot be used in SSR context.');
+    },
+    getLastElementChild(..._) {
+        throw new Error('renderer.getLastElementChild cannot be used in SSR context.');
+    },
+    getTagName(..._) {
+        throw new Error('renderer.getTagName cannot be used in SSR context.');
+    },
+    getStyle(..._) {
+        throw new Error('renderer.getStyle cannot be used in SSR context.');
+    },
+    isConnected(..._) {
+        throw new Error('renderer.isConnected cannot be used in SSR context.');
+    },
+    insertStylesheet(..._) {
+        throw new Error('renderer.insertStylesheet cannot be used in SSR context.');
+    },
+    assertInstanceOfHTMLElement(..._) {
+        throw new Error('renderer.assertInstanceOfHTMLElement cannot be used in SSR context.');
+    },
+    ownerDocument(..._) {
+        throw new Error('renderer.ownerDocument cannot be used in SSR context.');
+    },
+    registerContextConsumer(..._) {
+        throw new Error('renderer.registerContextConsumer cannot be used in SSR context.');
+    },
+    attachInternals(..._) {
+        throw new Error('renderer.attachInternals cannot be used in SSR context.');
+    },
+    defineCustomElement(..._) {
+        throw new Error('renderer.defineCustomElement cannot be used in SSR context.');
+    },
+    getParentNode(..._) {
+        throw new Error('renderer.getParentNode cannot be used in SSR context.');
+    },
+    startTrackingMutations(..._) {
+        throw new Error('renderer.startTrackingMutations cannot be used in SSR context.');
+    },
+    stopTrackingMutations(..._) {
+        throw new Error('renderer.stopTrackingMutations cannot be used in SSR context.');
+    },
+};
+/**
+ * The hot API is used to orchestrate hot swapping in client rendered components.
+ * It doesn't do anything on the server side, however, you may import it.
+ *
+ * The whole point of defining this and exporting it is so that you can import it in isomorphic code without
+ * an error being thrown by the import itself.
+ */
+// A real stub, not a "not implemented" one! 😯
+const hot = undefined;
+
+/*
+ * 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
+ */
+/**
+ * Converts an iterable into one that emits the object used by the [`iterator` directive](
+ * https://lwc.dev/guide/html_templates#iterator).
+ */
+function* toIteratorDirective(iterable) {
+    if (iterable === undefined || iterable === null)
+        return;
+    if (!iterable[Symbol.iterator]) {
+        throw new Error(
+        // Mimic error message from "[i]terable node" in engine-core's api.ts
+        `Invalid template iteration for value \`${iterable}\`. It must be an array-like object.`);
+    }
+    const iterator = iterable[Symbol.iterator]();
+    let next = iterator.next();
+    let index = 0;
+    let { value, done: last = false } = next;
+    while (last === false) {
+        // using a look-back approach because we need to know if the element is the last
+        next = iterator.next();
+        last = next.done ?? false;
+        yield {
+            value,
+            index,
+            first: index === 0,
+            last,
+        };
+        index += 1;
+        value = next.value;
+    }
+}
+
+/*
+ * 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
+ */
+/**
+ * Per the HTML spec on restrictions for "raw text elements" like `<style>`:
+ *
+ * > The text in raw text and escapable raw text elements must not contain any occurrences of the string
+ * > "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS) followed by characters that case-insensitively match the tag name of
+ * > the element followed by one of:
+ * > - U+0009 CHARACTER TABULATION (tab)
+ * > - U+000A LINE FEED (LF)
+ * > - U+000C FORM FEED (FF)
+ * > - U+000D CARRIAGE RETURN (CR)
+ * > - U+0020 SPACE
+ * > - U+003E GREATER-THAN SIGN (>), or
+ * > - U+002F SOLIDUS (/)
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
+ */
+const INVALID_STYLE_CONTENT = /<\/style[\t\n\f\r >/]/i;
+/**
+ * The text content inside `<style>` is a special case. It is _only_ rendered by the LWC engine itself; `<style>` tags
+ * are disallowed inside of HTML templates.
+ *
+ * The `<style>` tag is unusual in how it's defined in HTML. Like `<script>`, it is considered a "raw text element,"
+ * which means that it is parsed as raw text, but certain character sequences are disallowed, namely to avoid XSS
+ * attacks like `</style><script>alert("pwned")</script>`.
+ *
+ * This also means that we cannot use "normal" HTML escaping inside `<style>` tags, e.g. we cannot use `&lt;`,
+ * `&gt;`, etc., because these are treated as-is by the HTML parser.
+ *
+ *
+ * @param contents CSS source to validate
+ * @throws Throws if the contents provided are not valid.
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
+ * @see https://github.com/salesforce/lwc/issues/3439
+ * @example
+ * validateStyleTextContents('div { color: red }') // Ok
+ * validateStyleTextContents('</style><script>alert("pwned")</script>') // Throws
+ */
+function validateStyleTextContents(contents) {
+    if (INVALID_STYLE_CONTENT.test(contents)) {
+        throw new Error('CSS contains unsafe characters and cannot be serialized inside a style element');
+    }
+}
+
+export { ClassList, LightningElement, SYMBOL__SET_INTERNALS, api, createContextProvider, createElement, fallbackTmpl, freezeTemplate, getComponentDef, hot, isComponentConstructor, mutationTracker, parseFragment, parseSVGFragment, readonly, registerComponent, registerDecorators, registerTemplate, renderAttrs, serverSideRenderComponent as renderComponent, renderer, sanitizeAttribute, serverSideRenderComponent, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, toIteratorDirective, track, unwrap, validateStyleTextContents, wire };
+/** version: 8.3.0 */
 //# sourceMappingURL=index.js.map