@lwc/engine-core 6.2.0 → 6.2.1

package/dist/framework/api.d.ts

@@ -12,6 +12,7 @@ declare function c(sel: string, Ctor: LightningElementConstructor, data: VElemen
 declare function i(iterable: Iterable<any>, factory: (value: any, index: number, first: boolean, last: boolean) => VNodes | VNode): VNodes;
 /**
  * [f]lattening
+ * @param items
  */
 declare function f(items: Readonly<Array<Readonly<Array<VNodes>> | VNodes>>): VNodes;
 declare function t(text: string): VText;
@@ -25,15 +26,23 @@ declare function fid(url: string | undefined | null): string | null | undefined;
  * [ddc] - create a (deprecated) dynamic component via `<x-foo lwc:dynamic={Ctor}>`
  *
  * TODO [#3331]: remove usage of lwc:dynamic in 246
+ * @param sel
+ * @param Ctor
+ * @param data
+ * @param children
  */
 declare function ddc(sel: string, Ctor: LightningElementConstructor | null | undefined, data: VElementData, children?: VNodes): VCustomElement | null;
 /**
  * [dc] - create a dynamic component via `<lwc:component lwc:is={Ctor}>`
+ * @param Ctor
+ * @param data
+ * @param children
  */
 declare function dc(Ctor: LightningElementConstructor | null | undefined, data: VElementData, children?: VNodes): VCustomElement | null;
 export type SanitizeHtmlContentHook = (content: unknown) => string;
 /**
  * Sets the sanitizeHtmlContentHook.
+ * @param newHookImpl
  */
 export declare function setSanitizeHtmlContentHook(newHookImpl: SanitizeHtmlContentHook): void;
 declare function shc(content: unknown): string;

package/dist/framework/base-lightning-element.d.ts

@@ -43,7 +43,7 @@ export interface LightningElement extends HTMLElementTheGoodParts, AccessibleEle
 /**
  * This class is the base class for any LWC element.
  * Some elements directly extends this class, others implement it via inheritance.
- **/
+ */
 export declare const LightningElement: LightningElementConstructor;
 export declare const lightningBasedDescriptors: PropertyDescriptorMap;
 export {};

package/dist/framework/check-version-mismatch.d.ts

@@ -5,6 +5,8 @@ import { LightningElementConstructor } from './base-lightning-element';
  * Validate a template, stylesheet, or component to make sure that its compiled version matches
  * the version used by the LWC engine at runtime. Note that this only works in dev mode because
  * it relies on code comments, which are stripped in production due to minification.
+ * @param func
+ * @param type
  */
 export declare function checkVersionMismatch(func: Template, type: 'template'): void;
 export declare function checkVersionMismatch(func: StylesheetFactory, type: 'stylesheet'): void;

package/dist/framework/component.d.ts

@@ -12,6 +12,8 @@ type ComponentConstructorMetadata = {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param Ctor
+ * @param metadata
  */
 export declare function registerComponent(Ctor: any, metadata: ComponentConstructorMetadata): any;
 export declare function getComponentRegisteredTemplate(Ctor: LightningElementConstructor): Template | undefined;

package/dist/framework/decorators/api.d.ts

@@ -1,7 +1,10 @@
 /**
- * @api decorator to mark public fields and public methods in
+ * The @api decorator marks public fields and public methods in
  * LWC Components. This function implements the internals of this
  * decorator.
+ * @param target
+ * @param propertyKey
+ * @param descriptor
  */
 export default function api(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
 export declare function createPublicPropertyDescriptor(key: string): PropertyDescriptor;

package/dist/framework/decorators/register.d.ts

@@ -30,6 +30,8 @@ interface RegisterDecoratorMeta {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by user-land code.
+ * @param Ctor
+ * @param meta
  */
 export declare function registerDecorators(Ctor: LightningElementConstructor, meta: RegisterDecoratorMeta): LightningElementConstructor;
 interface DecoratorMeta {

package/dist/framework/decorators/track.d.ts

@@ -1,7 +1,10 @@
 /**
- * @track decorator function to mark field value as reactive in
+ * The @track decorator function marks field values as reactive in
  * LWC Components. This function can also be invoked directly
  * with any value to obtain the trackable version of the value.
+ * @param target
+ * @param propertyKey
+ * @param descriptor
  */
 export default function track(target: any, propertyKey: string, descriptor: PropertyDescriptor): any;
 export declare function internalTrackDecorator(key: string): PropertyDescriptor;

package/dist/framework/decorators/wire.d.ts

@@ -1,8 +1,10 @@
 import { WireAdapterConstructor } from '../wiring';
 /**
- * @wire decorator to wire fields and methods to a wire adapter in
+ * The @wire decorator wires fields and methods to a wire adapter in
  * LWC Components. This function implements the internals of this
  * decorator.
+ * @param _adapter
+ * @param _config
  */
 export default function wire(_adapter: WireAdapterConstructor, _config?: Record<string, any>): PropertyDecorator | MethodDecorator;
 export declare function internalWireFieldDecorator(key: string): PropertyDescriptor;

package/dist/framework/def.d.ts

@@ -36,6 +36,7 @@ export interface ComponentDef {
 /**
  * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
  * subject to change or being removed.
+ * @param ctor
  */
 export declare function isComponentConstructor(ctor: unknown): ctor is LightningElementConstructor;
 export declare function getComponentInternalDef(Ctor: unknown): ComponentDef;
@@ -58,6 +59,7 @@ interface PublicComponentDef {
 /**
  * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
  * subject to change or being removed.
+ * @param Ctor
  */
 export declare function getComponentDef(Ctor: any): PublicComponentDef;
 export {};

package/dist/framework/get-component-constructor.d.ts

@@ -2,5 +2,6 @@ import { LightningElement } from './base-lightning-element';
 /**
  * EXPERIMENTAL: This function provides access to the component constructor, given an HTMLElement.
  * This API is subject to change or being removed.
+ * @param elm
  */
 export declare function getComponentConstructor(elm: HTMLElement): typeof LightningElement | null;

package/dist/framework/membrane.d.ts

@@ -2,6 +2,7 @@
  * EXPERIMENTAL: This function implements an unwrap mechanism that
  * works for observable membrane objects. This API is subject to
  * change or being removed.
+ * @param value
  */
 export declare function unwrap(value: any): any;
 export declare function getReadOnlyProxy(value: any): any;

package/dist/framework/modules/static-parts.d.ts

@@ -2,17 +2,14 @@ import { VStatic } from '../vnodes';
 import { RendererAPI } from '../renderer';
 /**
  * Given an array of static parts, do all the mounting required for these parts.
- *
- * @param root - the root element
- * @param vnode - the parent VStatic
- * @param renderer - the renderer to use
- * @param mount - true this is a first (mount) render as opposed to a subsequent (patch) render
+ * @param root the root element
+ * @param vnode the parent VStatic
+ * @param renderer the renderer to use
  */
 export declare function mountStaticParts(root: Element, vnode: VStatic, renderer: RendererAPI): void;
 /**
  * Mounts elements to the newly generated VStatic node
- *
- * @param n1 - the previous VStatic vnode
- * @param n2 - the current VStatic vnode
+ * @param n1 the previous VStatic vnode
+ * @param n2 the current VStatic vnode
  */
 export declare function patchStaticParts(n1: VStatic, n2: VStatic): void;

package/dist/framework/readonly.d.ts

@@ -2,5 +2,6 @@
  * EXPERIMENTAL: This function allows you to create a reactive readonly
  * membrane around any object value. This API is subject to change or
  * being removed.
+ * @param obj
  */
 export declare function readonly(obj: any): any;

package/dist/framework/reporting.d.ts

@@ -49,13 +49,12 @@ export type ReportingPayloadMapping = {
     [ReportingEventId.ShadowSupportModeUsage]: ShadowSupportModeUsagePayload;
 };
 export type ReportingDispatcher<T extends ReportingEventId = ReportingEventId> = (reportingEventId: T, payload: ReportingPayloadMapping[T]) => void;
-/** Callbacks to invoke when reporting is enabled **/
+/** Callbacks to invoke when reporting is enabled */
 type OnReportingEnabledCallback = () => void;
 export declare const reportingControl: {
     /**
      * Attach a new reporting control (aka dispatcher).
-     *
-     * @param dispatcher - reporting control
+     * @param dispatcher reporting control
      */
     attachDispatcher(dispatcher: ReportingDispatcher): void;
     /**
@@ -72,7 +71,7 @@ export declare function onReportingEnabled(callback: OnReportingEnabledCallback)
 /**
  * Report to the current dispatcher, if there is one.
  * @param reportingEventId
- * @param payload - data to report
+ * @param payload data to report
  */
 export declare function report<T extends ReportingEventId>(reportingEventId: T, payload: ReportingPayloadMapping[T]): void;
 /**

package/dist/framework/secure-template.d.ts

@@ -4,10 +4,15 @@ export declare function isTemplateRegistered(tpl: Template): boolean;
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param tpl
  */
 export declare function registerTemplate(tpl: Template): Template;
 /**
  * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
  * libraries to sanitize vulnerable attributes.
+ * @param tagName
+ * @param namespaceUri
+ * @param attrName
+ * @param attrValue
  */
 export declare function sanitizeAttribute(tagName: string, namespaceUri: string, attrName: string, attrValue: any): string;

package/dist/framework/stylesheet.d.ts

@@ -8,8 +8,8 @@ import { VCustomElement, VNode } from './vnodes';
 export type StylesheetFactory = (stylesheetToken: string | undefined, useActualHostSelector: boolean, useNativeDirPseudoclass: boolean) => string;
 /**
  * The list of stylesheets associated with a template. Each entry is either a StylesheetFactory or a
- * TemplateStylesheetFactory a given stylesheet depends on other external stylesheets (via the
- * @import CSS declaration).
+ * TemplateStylesheetFactory a given stylesheet depends on other external stylesheets (via
+ * the @import CSS declaration).
  */
 export type TemplateStylesheetFactories = Array<StylesheetFactory | TemplateStylesheetFactories>;
 export declare function updateStylesheetToken(vm: VM, template: Template, legacy: boolean): void;
@@ -18,6 +18,8 @@ export declare function getStylesheetsContent(vm: VM, template: Template): strin
  * If the component that is currently being rendered uses scoped styles,
  * this returns the unique token for that scoped stylesheet. Otherwise
  * it returns null.
+ * @param owner
+ * @param legacy
  */
 export declare function getScopeTokenClass(owner: VM, legacy: boolean): string | null;
 /**
@@ -25,6 +27,7 @@ export declare function getScopeTokenClass(owner: VM, legacy: boolean): string |
  * exists. Otherwise it returns null.
  *
  * A host style token is applied to the component if scoped styles are used.
+ * @param vnode
  */
 export declare function getStylesheetTokenHost(vnode: VCustomElement): string | null;
 export declare function createStylesheet(vm: VM, stylesheets: string[]): VNode[] | null;

package/dist/framework/vm.d.ts

@@ -54,8 +54,10 @@ export interface Context {
     hasScopedStyles: boolean | undefined;
     /** The VNodes injected in all the shadow trees to apply the associated component stylesheets. */
     styleVNodes: VNode[] | null;
-    /** Object used by the template function to store information that can be reused between
-     *  different render cycle of the same template. */
+    /**
+     * Object used by the template function to store information that can be reused between
+     * different render cycle of the same template.
+     */
     tplCache: TemplateCache;
     /** List of wire hooks that are invoked when the component gets connected. */
     wiredConnecting: Array<() => void>;
@@ -94,16 +96,20 @@ export interface VM<N = HostNode, E = HostElement> {
     children: VNodes;
     /** The list of adopted children VNodes. */
     aChildren: VNodes;
-    /** The list of custom elements VNodes currently rendered in the shadow tree. We keep track of
+    /**
+     * The list of custom elements VNodes currently rendered in the shadow tree. We keep track of
      * those elements to efficiently unmount them when the parent component is disconnected without
-     * having to traverse the VNode tree. */
+     * having to traverse the VNode tree.
+     */
     velements: VCustomElement[];
     /** The component public properties. */
     cmpProps: {
         [name: string]: any;
     };
-    /** Contains information about the mapping between the slot names and the slotted VNodes, and
-     *  the owner of the slot content. */
+    /**
+     * Contains information about the mapping between the slot names and the slotted VNodes, and
+     * the owner of the slot content.
+     */
     cmpSlots: SlotSet;
     /** The component internal reactive properties. */
     cmpFields: {
@@ -121,28 +127,39 @@ export interface VM<N = HostNode, E = HostElement> {
     component: LightningElement;
     /** The custom element shadow root. */
     shadowRoot: ShadowRoot | null;
-    /** The component render root. If the component is a shadow DOM component, it is its shadow
-     * root. If the component is a light DOM component it the element itself. */
+    /**
+     * The component render root. If the component is a shadow DOM component, it is its shadow
+     * root. If the component is a light DOM component it the element itself.
+     */
     renderRoot: ShadowRoot | HostElement;
     /** The template reactive observer. */
     tro: ReactiveObserver;
-    /** Hook invoked whenever a property is accessed on the host element. This hook is used by
-     *  Locker only. */
+    /**
+     * Hook invoked whenever a property is accessed on the host element. This hook is used by
+     * Locker only.
+     */
     setHook: (cmp: LightningElement, prop: PropertyKey, newValue: any) => void;
-    /** Hook invoked whenever a property is set on the host element. This hook is used by Locker
-     *  only. */
+    /**
+     * Hook invoked whenever a property is set on the host element. This hook is used by Locker
+     * only.
+     */
     getHook: (cmp: LightningElement, prop: PropertyKey) => any;
-    /** Hook invoked whenever a method is called on the component (life-cycle hooks, public
-     *  properties and event handlers). This hook is used by Locker. */
+    /**
+     * Hook invoked whenever a method is called on the component (life-cycle hooks, public
+     * properties and event handlers). This hook is used by Locker.
+     */
     callHook: (cmp: LightningElement | undefined, fn: (...args: any[]) => any, args?: any[]) => any;
     /**
-     * Renderer API */
+     * Renderer API
+     */
     renderer: RendererAPI;
     /**
-     * Debug info bag. Stores useful debug information about the component. */
+     * Debug info bag. Stores useful debug information about the component.
+     */
     debugInfo?: Record<string, any>;
     /**
-     * Any stylesheets associated with the component */
+     * Any stylesheets associated with the component
+     */
     stylesheets: TemplateStylesheetFactories | null;
     /**
      * API version associated with this VM

package/dist/index.cjs.js

@@ -27,8 +27,7 @@ let enabled$1 = false;
 const reportingControl = {
     /**
      * Attach a new reporting control (aka dispatcher).
-     *
-     * @param dispatcher - reporting control
+     * @param dispatcher reporting control
      */
     attachDispatcher(dispatcher) {
         enabled$1 = true;
@@ -71,7 +70,7 @@ function onReportingEnabled(callback) {
 /**
  * Report to the current dispatcher, if there is one.
  * @param reportingEventId
- * @param payload - data to report
+ * @param payload data to report
  */
 function report(reportingEventId, payload) {
     if (enabled$1) {
@@ -1434,6 +1433,7 @@ const reactiveMembrane = new ObservableMembrane({
  * EXPERIMENTAL: This function implements an unwrap mechanism that
  * works for observable membrane objects. This API is subject to
  * change or being removed.
+ * @param value
  */
 function unwrap(value) {
     // On the server side, we don't need mutation tracking. Skipping it improves performance.
@@ -1547,6 +1547,8 @@ function applyShadowMigrateMode(shadowRoot) {
  * that a Custom Element can support (including AOM properties), which
  * determines what kind of capabilities the Base Lightning Element should support. When producing the new descriptors
  * for the Base Lightning Element, it also include the reactivity bit, so the standard property is reactive.
+ * @param propName
+ * @param descriptor
  */
 function createBridgeToElementDescriptor(propName, descriptor) {
     const { get, set, enumerable, configurable } = descriptor;
@@ -1596,7 +1598,7 @@ const refsCache = new WeakMap();
 /**
  * This class is the base class for any LWC element.
  * Some elements directly extends this class, others implement it via inheritance.
- **/
+ */
 // @ts-ignore
 const LightningElement = function () {
     // This should be as performant as possible, while any initialization should be done lazily
@@ -2465,9 +2467,11 @@ function internalTrackDecorator(key) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 /**
- * @wire decorator to wire fields and methods to a wire adapter in
+ * The @wire decorator wires fields and methods to a wire adapter in
  * LWC Components. This function implements the internals of this
  * decorator.
+ * @param _adapter
+ * @param _config
  */
 function wire(_adapter, _config) {
     if (process.env.NODE_ENV !== 'production') {
@@ -2578,6 +2582,8 @@ function validateMethodDecoratedWithApi(Ctor, methodName, descriptor) {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by user-land code.
+ * @param Ctor
+ * @param meta
  */
 function registerDecorators(Ctor, meta) {
     const proto = Ctor.prototype;
@@ -2766,6 +2772,7 @@ function isTemplateRegistered(tpl) {
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param tpl
  */
 function registerTemplate(tpl) {
     if (process.env.NODE_ENV !== 'production') {
@@ -2779,6 +2786,10 @@ function registerTemplate(tpl) {
 /**
  * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
  * libraries to sanitize vulnerable attributes.
+ * @param tagName
+ * @param namespaceUri
+ * @param attrName
+ * @param attrValue
  */
 function sanitizeAttribute(tagName, namespaceUri, attrName, attrValue) {
     // locker-service patches this function during runtime to sanitize vulnerable attributes. When
@@ -3364,6 +3375,7 @@ function createComponentDef(Ctor) {
 /**
  * EXPERIMENTAL: This function allows for the identification of LWC constructors. This API is
  * subject to change or being removed.
+ * @param ctor
  */
 function isComponentConstructor(ctor) {
     if (!shared.isFunction(ctor)) {
@@ -3437,6 +3449,7 @@ const lightingElementDef = {
 /**
  * EXPERIMENTAL: This function allows for the collection of internal component metadata. This API is
  * subject to change or being removed.
+ * @param Ctor
  */
 function getComponentDef(Ctor) {
     const def = getComponentInternalDef(Ctor);
@@ -3633,6 +3646,8 @@ function getNearestShadowComponent(vm) {
  * If the component that is currently being rendered uses scoped styles,
  * this returns the unique token for that scoped stylesheet. Otherwise
  * it returns null.
+ * @param owner
+ * @param legacy
  */
 // TODO [#3733]: remove support for legacy scope tokens
 function getScopeTokenClass(owner, legacy) {
@@ -3646,6 +3661,7 @@ function getScopeTokenClass(owner, legacy) {
  * exists. Otherwise it returns null.
  *
  * A host style token is applied to the component if scoped styles are used.
+ * @param vnode
  */
 function getStylesheetTokenHost(vnode) {
     const { template } = getComponentInternalDef(vnode.ctor);
@@ -4054,11 +4070,9 @@ function traverseAndSetElements(root, parts, renderer) {
 }
 /**
  * Given an array of static parts, do all the mounting required for these parts.
- *
- * @param root - the root element
- * @param vnode - the parent VStatic
- * @param renderer - the renderer to use
- * @param mount - true this is a first (mount) render as opposed to a subsequent (patch) render
+ * @param root the root element
+ * @param vnode the parent VStatic
+ * @param renderer the renderer to use
  */
 function mountStaticParts(root, vnode, renderer) {
     // On the server, we don't support ref (because it relies on renderedCallback), nor do we
@@ -4083,9 +4097,8 @@ function mountStaticParts(root, vnode, renderer) {
 }
 /**
  * Mounts elements to the newly generated VStatic node
- *
- * @param n1 - the previous VStatic vnode
- * @param n2 - the current VStatic vnode
+ * @param n1 the previous VStatic vnode
+ * @param n2 the current VStatic vnode
  */
 function patchStaticParts(n1, n2) {
     // On the server, we don't support ref (because it relies on renderedCallback), nor do we
@@ -4600,6 +4613,7 @@ function allocateChildren(vnode, vm) {
  * With the delimiters removed, the contents are marked dynamic so they are diffed correctly.
  *
  * This function is used for slotted VFragments to avoid the text delimiters interfering with slotting functionality.
+ * @param children
  */
 function flattenFragmentsInChildren(children) {
     const flattenedChildren = [];
@@ -5213,6 +5227,7 @@ function i(iterable, factory) {
 }
 /**
  * [f]lattening
+ * @param items
  */
 function f(items) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5329,6 +5344,10 @@ function fid(url) {
  * [ddc] - create a (deprecated) dynamic component via `<x-foo lwc:dynamic={Ctor}>`
  *
  * TODO [#3331]: remove usage of lwc:dynamic in 246
+ * @param sel
+ * @param Ctor
+ * @param data
+ * @param children
  */
 function ddc(sel, Ctor, data, children = EmptyArray) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5347,6 +5366,9 @@ function ddc(sel, Ctor, data, children = EmptyArray) {
 }
 /**
  * [dc] - create a dynamic component via `<lwc:component lwc:is={Ctor}>`
+ * @param Ctor
+ * @param data
+ * @param children
  */
 function dc(Ctor, data, children = EmptyArray) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5374,13 +5396,13 @@ function dc(Ctor, data, children = EmptyArray) {
  * to the engine that a particular collection of children must be diffed using the slow
  * algo based on keys due to the nature of the list. E.g.:
  *
- *   - slot element's children: the content of the slot has to be dynamic when in synthetic
- *                              shadow mode because the `vnode.children` might be the slotted
- *                              content vs default content, in which case the size and the
- *                              keys are not matching.
- *   - children that contain dynamic components
- *   - children that are produced by iteration
- *
+ * - slot element's children: the content of the slot has to be dynamic when in synthetic
+ * shadow mode because the `vnode.children` might be the slotted
+ * content vs default content, in which case the size and the
+ * keys are not matching.
+ * - children that contain dynamic components
+ * - children that are produced by iteration
+ * @param vnodes
  */
 function sc(vnodes) {
     if (process.env.NODE_ENV !== 'production') {
@@ -5404,6 +5426,7 @@ let sanitizeHtmlContentHook = () => {
 };
 /**
  * Sets the sanitizeHtmlContentHook.
+ * @param newHookImpl
  */
 function setSanitizeHtmlContentHook(newHookImpl) {
     sanitizeHtmlContentHook = newHookImpl;
@@ -5845,6 +5868,8 @@ const registeredComponentMap = new Map();
 /**
  * INTERNAL: This function can only be invoked by compiled code. The compiler
  * will prevent this function from being imported by userland code.
+ * @param Ctor
+ * @param metadata
  */
 function registerComponent(
 // We typically expect a LightningElementConstructor, but technically you can call this with anything
@@ -6202,7 +6227,7 @@ function computeShadowMode(def, owner, renderer, hydrated) {
     return shadowMode;
 }
 function assertIsVM(obj) {
-    if (shared.isNull(obj) || !shared.isObject(obj) || !('renderRoot' in obj)) {
+    if (!shared.isObject(obj) || shared.isNull(obj) || !('renderRoot' in obj)) {
         throw new TypeError(`${obj} is not a VM.`);
     }
 }
@@ -6395,6 +6420,7 @@ function runLightChildNodesDisconnectedCallback(vm) {
  * need to continue into its children because by attempting to disconnect the
  * custom element itself will trigger the removal of anything slotted or anything
  * defined on its shadow.
+ * @param vnodes
  */
 function recursivelyDisconnectChildren(vnodes) {
     for (let i = 0, len = vnodes.length; i < len; i += 1) {
@@ -7550,6 +7576,7 @@ function freezeTemplate(tmpl) {
 /**
  * EXPERIMENTAL: This function provides access to the component constructor, given an HTMLElement.
  * This API is subject to change or being removed.
+ * @param elm
  */
 function getComponentConstructor(elm) {
     let ctor = null;
@@ -7574,6 +7601,7 @@ function getComponentConstructor(elm) {
  * EXPERIMENTAL: This function allows you to create a reactive readonly
  * membrane around any object value. This API is subject to change or
  * being removed.
+ * @param obj
  */
 function readonly(obj) {
     if (process.env.NODE_ENV !== 'production') {
@@ -7628,5 +7656,5 @@ exports.swapTemplate = swapTemplate;
 exports.track = track;
 exports.unwrap = unwrap;
 exports.wire = wire;
-/** version: 6.2.0 */
+/** version: 6.2.1 */
 //# sourceMappingURL=index.cjs.js.map