@angular/core 19.1.2 → 19.1.3

package/fesm2022/core.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v19.1.2
+ * @license Angular v19.1.3
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -12267,6 +12267,55 @@ function nativeRemoveNode(renderer, rNode, isHostElement) {
 function clearElementContents(rElement) {
     rElement.textContent = '';
 }
+/**
+ * Write `cssText` to `RElement`.
+ *
+ * This function does direct write without any reconciliation. Used for writing initial values, so
+ * that static styling values do not pull in the style parser.
+ *
+ * @param renderer Renderer to use
+ * @param element The element which needs to be updated.
+ * @param newValue The new class list to write.
+ */
+function writeDirectStyle(renderer, element, newValue) {
+    ngDevMode && assertString(newValue, "'newValue' should be a string");
+    renderer.setAttribute(element, 'style', newValue);
+    ngDevMode && ngDevMode.rendererSetStyle++;
+}
+/**
+ * Write `className` to `RElement`.
+ *
+ * This function does direct write without any reconciliation. Used for writing initial values, so
+ * that static styling values do not pull in the style parser.
+ *
+ * @param renderer Renderer to use
+ * @param element The element which needs to be updated.
+ * @param newValue The new class list to write.
+ */
+function writeDirectClass(renderer, element, newValue) {
+    ngDevMode && assertString(newValue, "'newValue' should be a string");
+    if (newValue === '') {
+        // There are tests in `google3` which expect `element.getAttribute('class')` to be `null`.
+        renderer.removeAttribute(element, 'class');
+    }
+    else {
+        renderer.setAttribute(element, 'class', newValue);
+    }
+    ngDevMode && ngDevMode.rendererSetClassName++;
+}
+/** Sets up the static DOM attributes on an `RNode`. */
+function setupStaticAttributes(renderer, element, tNode) {
+    const { mergedAttrs, classes, styles } = tNode;
+    if (mergedAttrs !== null) {
+        setUpAttributes(renderer, element, mergedAttrs);
+    }
+    if (classes !== null) {
+        writeDirectClass(renderer, element, classes);
+    }
+    if (styles !== null) {
+        writeDirectStyle(renderer, element, styles);
+    }
+}
 
 function createLView(parentLView, tView, context, flags, host, tHostNode, environment, renderer, injector, embeddedViewInjector, hydrationInfo) {
     const lView = tView.blueprint.slice();
@@ -12301,67 +12350,6 @@ function createLView(parentLView, tView, context, flags, host, tHostNode, enviro
         tView.type == 2 /* TViewType.Embedded */ ? parentLView[DECLARATION_COMPONENT_VIEW] : lView;
     return lView;
 }
-function getOrCreateTNode(tView, index, type, name, attrs) {
-    ngDevMode &&
-        index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
-        // `view_engine_compatibility` for additional context.
-        assertGreaterThanOrEqual(index, HEADER_OFFSET, "TNodes can't be in the LView header.");
-    // Keep this function short, so that the VM will inline it.
-    ngDevMode && assertPureTNodeType(type);
-    let tNode = tView.data[index];
-    if (tNode === null) {
-        tNode = createTNodeAtIndex(tView, index, type, name, attrs);
-        if (isInI18nBlock()) {
-            // If we are in i18n block then all elements should be pre declared through `Placeholder`
-            // See `TNodeType.Placeholder` and `LFrame.inI18n` for more context.
-            // If the `TNode` was not pre-declared than it means it was not mentioned which means it was
-            // removed, so we mark it as detached.
-            tNode.flags |= 32 /* TNodeFlags.isDetached */;
-        }
-    }
-    else if (tNode.type & 64 /* TNodeType.Placeholder */) {
-        tNode.type = type;
-        tNode.value = name;
-        tNode.attrs = attrs;
-        const parent = getCurrentParentTNode();
-        tNode.injectorIndex = parent === null ? -1 : parent.injectorIndex;
-        ngDevMode && assertTNodeForTView(tNode, tView);
-        ngDevMode && assertEqual(index, tNode.index, 'Expecting same index');
-    }
-    setCurrentTNode(tNode, true);
-    return tNode;
-}
-function createTNodeAtIndex(tView, index, type, name, attrs) {
-    const currentTNode = getCurrentTNodePlaceholderOk();
-    const isParent = isCurrentTNodeParent();
-    const parent = isParent ? currentTNode : currentTNode && currentTNode.parent;
-    // Parents cannot cross component boundaries because components will be used in multiple places.
-    const tNode = (tView.data[index] = createTNode(tView, parent, type, index, name, attrs));
-    // Assign a pointer to the first child node of a given view. The first node is not always the one
-    // at index 0, in case of i18n, index 0 can be the instruction `i18nStart` and the first node has
-    // the index 1 or more, so we can't just check node index.
-    if (tView.firstChild === null) {
-        tView.firstChild = tNode;
-    }
-    if (currentTNode !== null) {
-        if (isParent) {
-            // FIXME(misko): This logic looks unnecessarily complicated. Could we simplify?
-            if (currentTNode.child == null && tNode.parent !== null) {
-                // We are in the same view, which means we are adding content node to the parent view.
-                currentTNode.child = tNode;
-            }
-        }
-        else {
-            if (currentTNode.next === null) {
-                // In the case of i18n the `currentTNode` may already be linked, in which case we don't want
-                // to break the links which i18n created.
-                currentTNode.next = tNode;
-                tNode.prev = currentTNode;
-            }
-        }
-    }
-    return tNode;
-}
 /**
  * When elements are created dynamically after a view blueprint is created (e.g. through
  * i18nApply()), we need to adjust the blueprint for future
@@ -12595,62 +12583,6 @@ function applyRootElementTransformImpl(rootElement) {
 function enableApplyRootElementTransformImpl() {
     _applyRootElementTransformImpl = applyRootElementTransformImpl;
 }
-function createTNode(tView, tParent, type, index, value, attrs) {
-    ngDevMode &&
-        index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
-        // `view_engine_compatibility` for additional context.
-        assertGreaterThanOrEqual(index, HEADER_OFFSET, "TNodes can't be in the LView header.");
-    ngDevMode && assertNotSame(attrs, undefined, "'undefined' is not valid value for 'attrs'");
-    ngDevMode && ngDevMode.tNode++;
-    ngDevMode && tParent && assertTNodeForTView(tParent, tView);
-    let injectorIndex = tParent ? tParent.injectorIndex : -1;
-    let flags = 0;
-    if (isInSkipHydrationBlock$1()) {
-        flags |= 128 /* TNodeFlags.inSkipHydrationBlock */;
-    }
-    const tNode = {
-        type,
-        index,
-        insertBeforeIndex: null,
-        injectorIndex,
-        directiveStart: -1,
-        directiveEnd: -1,
-        directiveStylingLast: -1,
-        componentOffset: -1,
-        propertyBindings: null,
-        flags,
-        providerIndexes: 0,
-        value: value,
-        attrs: attrs,
-        mergedAttrs: null,
-        localNames: null,
-        initialInputs: undefined,
-        inputs: null,
-        outputs: null,
-        tView: null,
-        next: null,
-        prev: null,
-        projectionNext: null,
-        child: null,
-        parent: tParent,
-        projection: null,
-        styles: null,
-        stylesWithoutHost: null,
-        residualStyles: undefined,
-        classes: null,
-        classesWithoutHost: null,
-        residualClasses: undefined,
-        classBindings: 0,
-        styleBindings: 0,
-    };
-    if (ngDevMode) {
-        // For performance reasons it is important that the tNode retains the same shape during runtime.
-        // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
-        // prevent class transitions.
-        Object.seal(tNode);
-    }
-    return tNode;
-}
 function captureNodeBindings(mode, aliasMap, directiveIndex, bindingsResult, hostDirectiveAliasMap) {
     for (let publicName in aliasMap) {
         if (!aliasMap.hasOwnProperty(publicName)) {
@@ -14436,55 +14368,6 @@ function applyStyling(renderer, isClassBased, rNode, prop, value) {
         }
     }
 }
-/**
- * Write `cssText` to `RElement`.
- *
- * This function does direct write without any reconciliation. Used for writing initial values, so
- * that static styling values do not pull in the style parser.
- *
- * @param renderer Renderer to use
- * @param element The element which needs to be updated.
- * @param newValue The new class list to write.
- */
-function writeDirectStyle(renderer, element, newValue) {
-    ngDevMode && assertString(newValue, "'newValue' should be a string");
-    renderer.setAttribute(element, 'style', newValue);
-    ngDevMode && ngDevMode.rendererSetStyle++;
-}
-/**
- * Write `className` to `RElement`.
- *
- * This function does direct write without any reconciliation. Used for writing initial values, so
- * that static styling values do not pull in the style parser.
- *
- * @param renderer Renderer to use
- * @param element The element which needs to be updated.
- * @param newValue The new class list to write.
- */
-function writeDirectClass(renderer, element, newValue) {
-    ngDevMode && assertString(newValue, "'newValue' should be a string");
-    if (newValue === '') {
-        // There are tests in `google3` which expect `element.getAttribute('class')` to be `null`.
-        renderer.removeAttribute(element, 'class');
-    }
-    else {
-        renderer.setAttribute(element, 'class', newValue);
-    }
-    ngDevMode && ngDevMode.rendererSetClassName++;
-}
-/** Sets up the static DOM attributes on an `RNode`. */
-function setupStaticAttributes(renderer, element, tNode) {
-    const { mergedAttrs, classes, styles } = tNode;
-    if (mergedAttrs !== null) {
-        setUpAttributes(renderer, element, mergedAttrs);
-    }
-    if (classes !== null) {
-        writeDirectClass(renderer, element, classes);
-    }
-    if (styles !== null) {
-        writeDirectStyle(renderer, element, styles);
-    }
-}
 
 function createAndRenderEmbeddedLView(declarationLView, templateTNode, context, options) {
     const prevConsumer = setActiveConsumer$1(null);
@@ -15996,6 +15879,128 @@ function processI18nInsertBefore(renderer, childTNode, lView, childRNode, parent
     }
 }
 
+function getOrCreateTNode(tView, index, type, name, attrs) {
+    ngDevMode &&
+        index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
+        // `view_engine_compatibility` for additional context.
+        assertGreaterThanOrEqual(index, HEADER_OFFSET, "TNodes can't be in the LView header.");
+    // Keep this function short, so that the VM will inline it.
+    ngDevMode && assertPureTNodeType(type);
+    let tNode = tView.data[index];
+    if (tNode === null) {
+        tNode = createTNodeAtIndex(tView, index, type, name, attrs);
+        if (isInI18nBlock()) {
+            // If we are in i18n block then all elements should be pre declared through `Placeholder`
+            // See `TNodeType.Placeholder` and `LFrame.inI18n` for more context.
+            // If the `TNode` was not pre-declared than it means it was not mentioned which means it was
+            // removed, so we mark it as detached.
+            tNode.flags |= 32 /* TNodeFlags.isDetached */;
+        }
+    }
+    else if (tNode.type & 64 /* TNodeType.Placeholder */) {
+        tNode.type = type;
+        tNode.value = name;
+        tNode.attrs = attrs;
+        const parent = getCurrentParentTNode();
+        tNode.injectorIndex = parent === null ? -1 : parent.injectorIndex;
+        ngDevMode && assertTNodeForTView(tNode, tView);
+        ngDevMode && assertEqual(index, tNode.index, 'Expecting same index');
+    }
+    setCurrentTNode(tNode, true);
+    return tNode;
+}
+function createTNodeAtIndex(tView, index, type, name, attrs) {
+    const currentTNode = getCurrentTNodePlaceholderOk();
+    const isParent = isCurrentTNodeParent();
+    const parent = isParent ? currentTNode : currentTNode && currentTNode.parent;
+    // Parents cannot cross component boundaries because components will be used in multiple places.
+    const tNode = (tView.data[index] = createTNode(tView, parent, type, index, name, attrs));
+    // Assign a pointer to the first child node of a given view. The first node is not always the one
+    // at index 0, in case of i18n, index 0 can be the instruction `i18nStart` and the first node has
+    // the index 1 or more, so we can't just check node index.
+    linkTNodeInTView(tView, tNode, currentTNode, isParent);
+    return tNode;
+}
+function linkTNodeInTView(tView, tNode, currentTNode, isParent) {
+    if (tView.firstChild === null) {
+        tView.firstChild = tNode;
+    }
+    if (currentTNode !== null) {
+        if (isParent) {
+            // FIXME(misko): This logic looks unnecessarily complicated. Could we simplify?
+            if (currentTNode.child == null && tNode.parent !== null) {
+                // We are in the same view, which means we are adding content node to the parent view.
+                currentTNode.child = tNode;
+            }
+        }
+        else {
+            if (currentTNode.next === null) {
+                // In the case of i18n the `currentTNode` may already be linked, in which case we don't want
+                // to break the links which i18n created.
+                currentTNode.next = tNode;
+                tNode.prev = currentTNode;
+            }
+        }
+    }
+}
+function createTNode(tView, tParent, type, index, value, attrs) {
+    ngDevMode &&
+        index !== 0 && // 0 are bogus nodes and they are OK. See `createContainerRef` in
+        // `view_engine_compatibility` for additional context.
+        assertGreaterThanOrEqual(index, HEADER_OFFSET, "TNodes can't be in the LView header.");
+    ngDevMode && assertNotSame(attrs, undefined, "'undefined' is not valid value for 'attrs'");
+    ngDevMode && ngDevMode.tNode++;
+    ngDevMode && tParent && assertTNodeForTView(tParent, tView);
+    let injectorIndex = tParent ? tParent.injectorIndex : -1;
+    let flags = 0;
+    if (isInSkipHydrationBlock$1()) {
+        flags |= 128 /* TNodeFlags.inSkipHydrationBlock */;
+    }
+    // TODO: would it be helpful to use a prototypal inheritance here, similar to the way we do so with signals?
+    const tNode = {
+        type,
+        index,
+        insertBeforeIndex: null,
+        injectorIndex,
+        directiveStart: -1,
+        directiveEnd: -1,
+        directiveStylingLast: -1,
+        componentOffset: -1,
+        propertyBindings: null,
+        flags,
+        providerIndexes: 0,
+        value: value,
+        attrs: attrs,
+        mergedAttrs: null,
+        localNames: null,
+        initialInputs: undefined,
+        inputs: null,
+        outputs: null,
+        tView: null,
+        next: null,
+        prev: null,
+        projectionNext: null,
+        child: null,
+        parent: tParent,
+        projection: null,
+        styles: null,
+        stylesWithoutHost: null,
+        residualStyles: undefined,
+        classes: null,
+        classesWithoutHost: null,
+        residualClasses: undefined,
+        classBindings: 0,
+        styleBindings: 0,
+    };
+    if (ngDevMode) {
+        // For performance reasons it is important that the tNode retains the same shape during runtime.
+        // (To make sure that all of the code is monomorphic.) For this reason we seal the object to
+        // prevent class transitions.
+        Object.seal(tNode);
+    }
+    return tNode;
+}
+
 /**
  * Add `tNode` to `previousTNodes` list and update relevant `TNode`s in `previousTNodes` list
  * `tNode.insertBeforeIndex`.
@@ -17917,6 +17922,7 @@ class ComponentFactory extends ComponentFactory$1 {
             // Create the root view. Uses empty TView and ContentTemplate.
             const rootTView = createTView(0 /* TViewType.Root */, null, null, 1, 0, null, null, null, null, null, null);
             const rootLView = createLView(null, rootTView, null, rootFlags, null, null, environment, hostRenderer, rootViewInjector, null, hydrationInfo);
+            rootLView[HEADER_OFFSET] = hostRNode;
             // rootView is the parent when bootstrapping
             // TODO(misko): it looks like we are entering view here but we don't really need to as
             // `renderView` does that. However as the code is written it is needed because
@@ -17924,7 +17930,6 @@ class ComponentFactory extends ComponentFactory$1 {
             // issues would allow us to drop this.
             enterView(rootLView);
             let component;
-            let tElementNode;
             let componentView = null;
             try {
                 const rootComponentDef = this.componentDef;
@@ -17940,12 +17945,13 @@ class ComponentFactory extends ComponentFactory$1 {
                 else {
                     rootDirectives = [rootComponentDef];
                 }
-                const hostTNode = createRootComponentTNode(rootLView, hostRNode);
                 // If host dom element is created (instead of being provided as part of the dynamic component creation), also apply attributes and classes extracted from component selector.
                 const tAttributes = rootSelectorOrNode
-                    ? ['ng-version', '19.1.2']
+                    ? ['ng-version', '19.1.3']
                     : // Extract attributes and classes from the first selector only to match VE behavior.
                         getRootTAttributesFromSelector(this.componentDef.selectors[0]);
+                // TODO: this logic is shared with the element instruction first create pass
+                const hostTNode = getOrCreateTNode(rootTView, HEADER_OFFSET, 2 /* TNodeType.Element */, '#host', tAttributes);
                 for (const def of rootDirectives) {
                     hostTNode.mergedAttrs = mergeHostAttrs(hostTNode.mergedAttrs, def.hostAttrs);
                 }
@@ -17958,7 +17964,6 @@ class ComponentFactory extends ComponentFactory$1 {
                     setupStaticAttributes(hostRenderer, hostRNode, hostTNode);
                 }
                 componentView = createRootComponentView(hostTNode, hostRNode, rootComponentDef, rootDirectives, rootLView, environment);
-                tElementNode = getTNode(rootTView, HEADER_OFFSET);
                 if (projectableNodes !== undefined) {
                     projectNodes(hostTNode, this.ngContentSelectors, projectableNodes);
                 }
@@ -17979,7 +17984,8 @@ class ComponentFactory extends ComponentFactory$1 {
             finally {
                 leaveView();
             }
-            return new ComponentRef(this.componentType, component, createElementRef(tElementNode, rootLView), rootLView, tElementNode);
+            const hostTNode = getTNode(rootTView, HEADER_OFFSET);
+            return new ComponentRef(this.componentType, component, createElementRef(hostTNode, rootLView), rootLView, hostTNode);
         }
         finally {
             setActiveConsumer$1(prevConsumer);
@@ -18048,17 +18054,6 @@ class ComponentRef extends ComponentRef$1 {
         this.hostView.onDestroy(callback);
     }
 }
-/** Creates a TNode that can be used to instantiate a root component. */
-function createRootComponentTNode(lView, rNode) {
-    const tView = lView[TVIEW];
-    const index = HEADER_OFFSET;
-    ngDevMode && assertIndexInRange(lView, index);
-    lView[index] = rNode;
-    // '#host' is added here as we don't know the real host DOM name (we don't want to read it) and at
-    // the same time we want to communicate the debug `TNode` that this is a special `TNode`
-    // representing a host element.
-    return getOrCreateTNode(tView, index, 2 /* TNodeType.Element */, '#host', null);
-}
 /**
  * Creates the root component view and the root component node.
  *
@@ -20072,7 +20067,11 @@ function getComponentId(componentDef) {
     // 2147483647 = equivalent of Integer.MAX_VALUE.
     hash += 2147483647 + 1;
     const compId = 'c' + hash;
-    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+        // Skip the check on the server since we can't guarantee the same component instance between
+        // requests. Note that we can't use DI to check if we're on the server, because the component
+        // hasn't been instantiated yet.
+        (typeof ngServerMode === 'undefined' || !ngServerMode)) {
         if (GENERATED_COMP_IDS.has(compId)) {
             const previousCompDefType = GENERATED_COMP_IDS.get(compId);
             if (previousCompDefType !== componentDef.type) {
@@ -33413,13 +33412,18 @@ function ɵsetClassDebugInfo(type, debugInfo) {
  */
 function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals) {
     ngDevMode && assertComponentDef(type);
-    const oldDef = getComponentDef(type);
+    const currentDef = getComponentDef(type);
     // The reason `applyMetadata` is a callback that is invoked (almost) immediately is because
     // the compiler usually produces more code than just the component definition, e.g. there
     // can be functions for embedded views, the variables for the constant pool and `setClassMetadata`
     // calls. The callback allows us to keep them isolate from the rest of the app and to invoke
     // them at the right time.
     applyMetadata.apply(null, [type, namespaces, ...locals]);
+    const { newDef, oldDef } = mergeWithExistingDefinition(currentDef, getComponentDef(type));
+    // TODO(crisbeto): the `applyMetadata` call above will replace the definition on the type.
+    // Ideally we should adjust the compiler output so the metadata is returned, however that'll
+    // require some internal changes. We re-add the metadata here manually.
+    type[NG_COMP_DEF] = newDef;
     // If a `tView` hasn't been created yet, it means that this component hasn't been instantianted
     // before. In this case there's nothing left for us to do aside from patching it in.
     if (oldDef.tView) {
@@ -33428,17 +33432,42 @@ function ɵɵreplaceMetadata(type, applyMetadata, namespaces, locals) {
             // Note: we have the additional check, because `IsRoot` can also indicate
             // a component created through something like `createComponent`.
             if (root[FLAGS] & 512 /* LViewFlags.IsRoot */ && root[PARENT] === null) {
-                recreateMatchingLViews(oldDef, root);
+                recreateMatchingLViews(newDef, oldDef, root);
             }
         }
     }
 }
+/**
+ * Merges two component definitions while preseving the original one in place.
+ * @param currentDef Definition that should receive the new metadata.
+ * @param newDef Source of the new metadata.
+ */
+function mergeWithExistingDefinition(currentDef, newDef) {
+    // Clone the current definition since we reference its original data further
+    // down in the replacement process (e.g. when destroying the renderer).
+    const clone = { ...currentDef };
+    // Assign the new metadata in place while preserving the object literal. It's important to
+    // Keep the object in place, because there can be references to it, for example in the
+    // `directiveDefs` of another definition.
+    const replacement = Object.assign(currentDef, newDef, {
+        // We need to keep the existing directive and pipe defs, because they can get patched on
+        // by a call to `setComponentScope` from a module file. That call won't make it into the
+        // HMR replacement function, because it lives in an entirely different file.
+        directiveDefs: clone.directiveDefs,
+        pipeDefs: clone.pipeDefs,
+        // Preserve the old `setInput` function, because it has some state.
+        // This is fine, because the component instance is preserved as well.
+        setInput: clone.setInput,
+    });
+    ngDevMode && assertEqual(replacement, currentDef, 'Expected definition to be merged in place');
+    return { newDef: replacement, oldDef: clone };
+}
 /**
  * Finds all LViews matching a specific component definition and recreates them.
  * @param oldDef Component definition to search for.
  * @param rootLView View from which to start the search.
  */
-function recreateMatchingLViews(oldDef, rootLView) {
+function recreateMatchingLViews(newDef, oldDef, rootLView) {
     ngDevMode &&
         assertDefined(oldDef.tView, 'Expected a component definition that has been instantiated at least once');
     const tView = rootLView[TVIEW];
@@ -33446,7 +33475,7 @@ function recreateMatchingLViews(oldDef, rootLView) {
     // produce false positives when using inheritance.
     if (tView === oldDef.tView) {
         ngDevMode && assertComponentDef(oldDef.type);
-        recreateLView(getComponentDef(oldDef.type), oldDef, rootLView);
+        recreateLView(newDef, oldDef, rootLView);
         return;
     }
     for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
@@ -33454,14 +33483,14 @@ function recreateMatchingLViews(oldDef, rootLView) {
         if (isLContainer(current)) {
             // The host can be an LView if a component is injecting `ViewContainerRef`.
             if (isLView(current[HOST])) {
-                recreateMatchingLViews(oldDef, current[HOST]);
+                recreateMatchingLViews(newDef, oldDef, current[HOST]);
             }
             for (let j = CONTAINER_HEADER_OFFSET; j < current.length; j++) {
-                recreateMatchingLViews(oldDef, current[j]);
+                recreateMatchingLViews(newDef, oldDef, current[j]);
             }
         }
         else if (isLView(current)) {
-            recreateMatchingLViews(oldDef, current);
+            recreateMatchingLViews(newDef, oldDef, current);
         }
     }
 }
@@ -34967,7 +34996,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = new Version('19.1.2');
+const VERSION = new Version('19.1.3');
 
 /**
  * Combination of NgModuleFactory and ComponentFactories.
@@ -38875,6 +38904,91 @@ function signalValueChanged(node) {
     postSignalSetFn?.();
 }
 
+function createLinkedSignal$1(sourceFn, computationFn, equalityFn) {
+    const node = Object.create(LINKED_SIGNAL_NODE$1);
+    node.source = sourceFn;
+    node.computation = computationFn;
+    if (equalityFn != undefined) {
+        node.equal = equalityFn;
+    }
+    const linkedSignalGetter = () => {
+        // Check if the value needs updating before returning it.
+        producerUpdateValueVersion(node);
+        // Record that someone looked at this signal.
+        producerAccessed(node);
+        if (node.value === ERRORED$1) {
+            throw node.error;
+        }
+        return node.value;
+    };
+    const getter = linkedSignalGetter;
+    getter[SIGNAL] = node;
+    return getter;
+}
+function linkedSignalSetFn(node, newValue) {
+    producerUpdateValueVersion(node);
+    signalSetFn(node, newValue);
+    producerMarkClean(node);
+}
+function linkedSignalUpdateFn(node, updater) {
+    producerUpdateValueVersion(node);
+    signalUpdateFn(node, updater);
+    producerMarkClean(node);
+}
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `LINKED_SIGNAL_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+const LINKED_SIGNAL_NODE$1 = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        value: UNSET$1,
+        dirty: true,
+        error: null,
+        equal: defaultEquals,
+        producerMustRecompute(node) {
+            // Force a recomputation if there's no current value, or if the current value is in the
+            // process of being calculated (which should throw an error).
+            return node.value === UNSET$1 || node.value === COMPUTING$1;
+        },
+        producerRecomputeValue(node) {
+            if (node.value === COMPUTING$1) {
+                // Our computation somehow led to a cyclic read of itself.
+                throw new Error('Detected cycle in computations.');
+            }
+            const oldValue = node.value;
+            node.value = COMPUTING$1;
+            const prevConsumer = consumerBeforeComputation(node);
+            let newValue;
+            try {
+                const newSourceValue = node.source();
+                const prev = oldValue === UNSET$1 || oldValue === ERRORED$1
+                    ? undefined
+                    : {
+                        source: node.sourceValue,
+                        value: oldValue,
+                    };
+                newValue = node.computation(newSourceValue, prev);
+                node.sourceValue = newSourceValue;
+            }
+            catch (err) {
+                newValue = ERRORED$1;
+                node.error = err;
+            }
+            finally {
+                consumerAfterComputation(node, prevConsumer);
+            }
+            if (oldValue !== UNSET$1 && newValue !== ERRORED$1 && node.equal(oldValue, newValue)) {
+                // No change to `valueVersion` - old and new values are
+                // semantically equivalent.
+                node.value = oldValue;
+                return;
+            }
+            node.value = newValue;
+            node.version++;
+        },
+    };
+})();
+
 function createWatch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
     if (allowSignalWrites) {