@angular/core 17.2.0-next.0 → 17.2.0-rc.0

package/esm2022/src/application/application_tokens.mjs

@@ -37,7 +37,7 @@ import { getDocument } from '../render3/interfaces/document';
  *
  * @publicApi
  */
-export const APP_ID = new InjectionToken('AppId', {
+export const APP_ID = new InjectionToken(ngDevMode ? 'AppId' : '', {
     providedIn: 'root',
     factory: () => DEFAULT_APP_ID,
 });
@@ -47,12 +47,12 @@ const DEFAULT_APP_ID = 'ng';
  * A function that is executed when a platform is initialized.
  * @publicApi
  */
-export const PLATFORM_INITIALIZER = new InjectionToken('Platform Initializer');
+export const PLATFORM_INITIALIZER = new InjectionToken(ngDevMode ? 'Platform Initializer' : '');
 /**
  * A token that indicates an opaque platform ID.
  * @publicApi
  */
-export const PLATFORM_ID = new InjectionToken('Platform ID', {
+export const PLATFORM_ID = new InjectionToken(ngDevMode ? 'Platform ID' : '', {
     providedIn: 'platform',
     factory: () => 'unknown', // set a default platform name, when none set explicitly
 });
@@ -62,16 +62,16 @@ export const PLATFORM_ID = new InjectionToken('Platform ID', {
  * @publicApi
  * @deprecated
  */
-export const PACKAGE_ROOT_URL = new InjectionToken('Application Packages Root URL');
+export const PACKAGE_ROOT_URL = new InjectionToken(ngDevMode ? 'Application Packages Root URL' : '');
 // We keep this token here, rather than the animations package, so that modules that only care
 // about which animations module is loaded (e.g. the CDK) can retrieve it without having to
 // include extra dependencies. See #44970 for more context.
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that indicates which animations
+ * A [DI token](api/core/InjectionToken) that indicates which animations
  * module has been loaded.
  * @publicApi
  */
-export const ANIMATION_MODULE_TYPE = new InjectionToken('AnimationModuleType');
+export const ANIMATION_MODULE_TYPE = new InjectionToken(ngDevMode ? 'AnimationModuleType' : '');
 // TODO(crisbeto): link to CSP guide here.
 /**
  * Token used to configure the [Content Security Policy](https://web.dev/strict-csp/) nonce that
@@ -80,7 +80,7 @@ export const ANIMATION_MODULE_TYPE = new InjectionToken('AnimationModuleType');
  *
  * @publicApi
  */
-export const CSP_NONCE = new InjectionToken('CSP nonce', {
+export const CSP_NONCE = new InjectionToken(ngDevMode ? 'CSP nonce' : '', {
     providedIn: 'root',
     factory: () => {
         // Ideally we wouldn't have to use `querySelector` here since we know that the nonce will be on
@@ -105,6 +105,7 @@ export const CSP_NONCE = new InjectionToken('CSP nonce', {
 });
 export const IMAGE_CONFIG_DEFAULTS = {
     breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+    placeholderResolution: 30,
     disableImageSizeWarning: false,
     disableImageLazyLoadWarning: false,
 };
@@ -117,5 +118,5 @@ export const IMAGE_CONFIG_DEFAULTS = {
  * @see {@link ImageConfig}
  * @publicApi
  */
-export const IMAGE_CONFIG = new InjectionToken('ImageConfig', { providedIn: 'root', factory: () => IMAGE_CONFIG_DEFAULTS });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application_tokens.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/application_tokens.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,cAAc,CAAS,OAAO,EAAE;IACxD,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC,cAAc;CAC9B,CAAC,CAAC;AAEH,2CAA2C;AAC3C,MAAM,cAAc,GAAG,IAAI,CAAC;AAE5B;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAC7B,IAAI,cAAc,CAA4B,sBAAsB,CAAC,CAAC;AAE1E;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,cAAc,CAAS,aAAa,EAAE;IACnE,UAAU,EAAE,UAAU;IACtB,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS,EAAG,wDAAwD;CACpF,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAAS,+BAA+B,CAAC,CAAC;AAE5F,8FAA8F;AAC9F,2FAA2F;AAC3F,2DAA2D;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAC9B,IAAI,cAAc,CAAuC,qBAAqB,CAAC,CAAC;AAEpF,0CAA0C;AAC1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,cAAc,CAAc,WAAW,EAAE;IACpE,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE;QACZ,+FAA+F;QAC/F,0FAA0F;QAC1F,6FAA6F;QAC7F,sFAAsF;QACtF,8FAA8F;QAC9F,6FAA6F;QAC7F,uBAAuB;QACvB,yFAAyF;QACzF,+FAA+F;QAC/F,kCAAkC;QAClC,+FAA+F;QAC/F,4FAA4F;QAC5F,+FAA+F;QAC/F,0BAA0B;QAC1B,6FAA6F;QAC7F,8FAA8F;QAC9F,+EAA+E;QAC/E,OAAO,WAAW,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC;IAC/F,CAAC;CACF,CAAC,CAAC;AAqBH,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IAChD,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;IAC7F,uBAAuB,EAAE,KAAK;IAC9B,2BAA2B,EAAE,KAAK;CACnC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAC1C,aAAa,EAAE,EAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,qBAAqB,EAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../di/injection_token';\nimport {getDocument} from '../render3/interfaces/document';\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") representing a string ID, used\n * primarily for prefixing application attributes and CSS styles when\n * {@link ViewEncapsulation#Emulated} is being used.\n *\n * The token is needed in cases when multiple applications are bootstrapped on a page\n * (for example, using `bootstrapApplication` calls). In this case, ensure that those applications\n * have different `APP_ID` value setup. For example:\n *\n * ```\n * bootstrapApplication(ComponentA, {\n *   providers: [\n *     { provide: APP_ID, useValue: 'app-a' },\n *     // ... other providers ...\n *   ]\n * });\n *\n * bootstrapApplication(ComponentB, {\n *   providers: [\n *     { provide: APP_ID, useValue: 'app-b' },\n *     // ... other providers ...\n *   ]\n * });\n * ```\n *\n * By default, when there is only one application bootstrapped, you don't need to provide the\n * `APP_ID` token (the `ng` will be used as an app ID).\n *\n * @publicApi\n */\nexport const APP_ID = new InjectionToken<string>('AppId', {\n  providedIn: 'root',\n  factory: () => DEFAULT_APP_ID,\n});\n\n/** Default value of the `APP_ID` token. */\nconst DEFAULT_APP_ID = 'ng';\n\n/**\n * A function that is executed when a platform is initialized.\n * @publicApi\n */\nexport const PLATFORM_INITIALIZER =\n    new InjectionToken<ReadonlyArray<() => void>>('Platform Initializer');\n\n/**\n * A token that indicates an opaque platform ID.\n * @publicApi\n */\nexport const PLATFORM_ID = new InjectionToken<Object>('Platform ID', {\n  providedIn: 'platform',\n  factory: () => 'unknown',  // set a default platform name, when none set explicitly\n});\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") that indicates the root directory of\n * the application\n * @publicApi\n * @deprecated\n */\nexport const PACKAGE_ROOT_URL = new InjectionToken<string>('Application Packages Root URL');\n\n// We keep this token here, rather than the animations package, so that modules that only care\n// about which animations module is loaded (e.g. the CDK) can retrieve it without having to\n// include extra dependencies. See #44970 for more context.\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") that indicates which animations\n * module has been loaded.\n * @publicApi\n */\nexport const ANIMATION_MODULE_TYPE =\n    new InjectionToken<'NoopAnimations'|'BrowserAnimations'>('AnimationModuleType');\n\n// TODO(crisbeto): link to CSP guide here.\n/**\n * Token used to configure the [Content Security Policy](https://web.dev/strict-csp/) nonce that\n * Angular will apply when inserting inline styles. If not provided, Angular will look up its value\n * from the `ngCspNonce` attribute of the application root node.\n *\n * @publicApi\n */\nexport const CSP_NONCE = new InjectionToken<string|null>('CSP nonce', {\n  providedIn: 'root',\n  factory: () => {\n    // Ideally we wouldn't have to use `querySelector` here since we know that the nonce will be on\n    // the root node, but because the token value is used in renderers, it has to be available\n    // *very* early in the bootstrapping process. This should be a fairly shallow search, because\n    // the app won't have been added to the DOM yet. Some approaches that were considered:\n    // 1. Find the root node through `ApplicationRef.components[i].location` - normally this would\n    // be enough for our purposes, but the token is injected very early so the `components` array\n    // isn't populated yet.\n    // 2. Find the root `LView` through the current `LView` - renderers are a prerequisite to\n    // creating the `LView`. This means that no `LView` will have been entered when this factory is\n    // invoked for the root component.\n    // 3. Have the token factory return `() => string` which is invoked when a nonce is requested -\n    // the slightly later execution does allow us to get an `LView` reference, but the fact that\n    // it is a function means that it could be executed at *any* time (including immediately) which\n    // may lead to weird bugs.\n    // 4. Have the `ComponentFactory` read the attribute and provide it to the injector under the\n    // hood - has the same problem as #1 and #2 in that the renderer is used to query for the root\n    // node and the nonce value needs to be available when the renderer is created.\n    return getDocument().body?.querySelector('[ngCspNonce]')?.getAttribute('ngCspNonce') || null;\n  },\n});\n\n/**\n * A configuration object for the image-related options. Contains:\n * - breakpoints: An array of integer breakpoints used to generate\n *      srcsets for responsive images.\n * - disableImageSizeWarning: A boolean value. Setting this to true will\n *      disable console warnings about oversized images.\n * - disableImageLazyLoadWarning: A boolean value. Setting this to true will\n *      disable console warnings about LCP images configured with `loading=\"lazy\"`.\n * Learn more about the responsive image configuration in [the NgOptimizedImage\n * guide](guide/image-directive).\n * Learn more about image warning options in [the related error page](errors/NG0913).\n * @publicApi\n */\nexport type ImageConfig = {\n  breakpoints?: number[],\n  disableImageSizeWarning?: boolean,\n  disableImageLazyLoadWarning?: boolean,\n};\n\nexport const IMAGE_CONFIG_DEFAULTS: ImageConfig = {\n  breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],\n  disableImageSizeWarning: false,\n  disableImageLazyLoadWarning: false,\n};\n\n/**\n * Injection token that configures the image optimized image functionality.\n * See {@link ImageConfig} for additional information about parameters that\n * can be used.\n *\n * @see {@link NgOptimizedImage}\n * @see {@link ImageConfig}\n * @publicApi\n */\nexport const IMAGE_CONFIG = new InjectionToken<ImageConfig>(\n    'ImageConfig', {providedIn: 'root', factory: () => IMAGE_CONFIG_DEFAULTS});\n"]}
+export const IMAGE_CONFIG = new InjectionToken(ngDevMode ? 'ImageConfig' : '', { providedIn: 'root', factory: () => IMAGE_CONFIG_DEFAULTS });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application_tokens.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/application_tokens.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,cAAc,CAAS,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;IACzE,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE,CAAC,cAAc;CAC9B,CAAC,CAAC;AAEH,2CAA2C;AAC3C,MAAM,cAAc,GAAG,IAAI,CAAC;AAE5B;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAC7B,IAAI,cAAc,CAA4B,SAAS,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAE3F;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,cAAc,CAAS,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE;IACpF,UAAU,EAAE,UAAU;IACtB,OAAO,EAAE,GAAG,EAAE,CAAC,SAAS,EAAG,wDAAwD;CACpF,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GACzB,IAAI,cAAc,CAAS,SAAS,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAEjF,8FAA8F;AAC9F,2FAA2F;AAC3F,2DAA2D;AAE3D;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,cAAc,CACnD,SAAS,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;AAE5C,0CAA0C;AAC1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,cAAc,CAAc,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE;IACrF,UAAU,EAAE,MAAM;IAClB,OAAO,EAAE,GAAG,EAAE;QACZ,+FAA+F;QAC/F,0FAA0F;QAC1F,6FAA6F;QAC7F,sFAAsF;QACtF,8FAA8F;QAC9F,6FAA6F;QAC7F,uBAAuB;QACvB,yFAAyF;QACzF,+FAA+F;QAC/F,kCAAkC;QAClC,+FAA+F;QAC/F,4FAA4F;QAC5F,+FAA+F;QAC/F,0BAA0B;QAC1B,6FAA6F;QAC7F,8FAA8F;QAC9F,+EAA+E;QAC/E,OAAO,WAAW,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC;IAC/F,CAAC;CACF,CAAC,CAAC;AAsBH,MAAM,CAAC,MAAM,qBAAqB,GAAgB;IAChD,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;IAC7F,qBAAqB,EAAE,EAAE;IACzB,uBAAuB,EAAE,KAAK;IAC9B,2BAA2B,EAAE,KAAK;CACnC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,cAAc,CAC1C,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,EAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,qBAAqB,EAAC,CAAC,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {InjectionToken} from '../di/injection_token';\nimport {getDocument} from '../render3/interfaces/document';\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") representing a string ID, used\n * primarily for prefixing application attributes and CSS styles when\n * {@link ViewEncapsulation#Emulated} is being used.\n *\n * The token is needed in cases when multiple applications are bootstrapped on a page\n * (for example, using `bootstrapApplication` calls). In this case, ensure that those applications\n * have different `APP_ID` value setup. For example:\n *\n * ```\n * bootstrapApplication(ComponentA, {\n *   providers: [\n *     { provide: APP_ID, useValue: 'app-a' },\n *     // ... other providers ...\n *   ]\n * });\n *\n * bootstrapApplication(ComponentB, {\n *   providers: [\n *     { provide: APP_ID, useValue: 'app-b' },\n *     // ... other providers ...\n *   ]\n * });\n * ```\n *\n * By default, when there is only one application bootstrapped, you don't need to provide the\n * `APP_ID` token (the `ng` will be used as an app ID).\n *\n * @publicApi\n */\nexport const APP_ID = new InjectionToken<string>(ngDevMode ? 'AppId' : '', {\n  providedIn: 'root',\n  factory: () => DEFAULT_APP_ID,\n});\n\n/** Default value of the `APP_ID` token. */\nconst DEFAULT_APP_ID = 'ng';\n\n/**\n * A function that is executed when a platform is initialized.\n * @publicApi\n */\nexport const PLATFORM_INITIALIZER =\n    new InjectionToken<ReadonlyArray<() => void>>(ngDevMode ? 'Platform Initializer' : '');\n\n/**\n * A token that indicates an opaque platform ID.\n * @publicApi\n */\nexport const PLATFORM_ID = new InjectionToken<Object>(ngDevMode ? 'Platform ID' : '', {\n  providedIn: 'platform',\n  factory: () => 'unknown',  // set a default platform name, when none set explicitly\n});\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") that indicates the root directory of\n * the application\n * @publicApi\n * @deprecated\n */\nexport const PACKAGE_ROOT_URL =\n    new InjectionToken<string>(ngDevMode ? 'Application Packages Root URL' : '');\n\n// We keep this token here, rather than the animations package, so that modules that only care\n// about which animations module is loaded (e.g. the CDK) can retrieve it without having to\n// include extra dependencies. See #44970 for more context.\n\n/**\n * A [DI token](api/core/InjectionToken) that indicates which animations\n * module has been loaded.\n * @publicApi\n */\nexport const ANIMATION_MODULE_TYPE = new InjectionToken<'NoopAnimations'|'BrowserAnimations'>(\n    ngDevMode ? 'AnimationModuleType' : '');\n\n// TODO(crisbeto): link to CSP guide here.\n/**\n * Token used to configure the [Content Security Policy](https://web.dev/strict-csp/) nonce that\n * Angular will apply when inserting inline styles. If not provided, Angular will look up its value\n * from the `ngCspNonce` attribute of the application root node.\n *\n * @publicApi\n */\nexport const CSP_NONCE = new InjectionToken<string|null>(ngDevMode ? 'CSP nonce' : '', {\n  providedIn: 'root',\n  factory: () => {\n    // Ideally we wouldn't have to use `querySelector` here since we know that the nonce will be on\n    // the root node, but because the token value is used in renderers, it has to be available\n    // *very* early in the bootstrapping process. This should be a fairly shallow search, because\n    // the app won't have been added to the DOM yet. Some approaches that were considered:\n    // 1. Find the root node through `ApplicationRef.components[i].location` - normally this would\n    // be enough for our purposes, but the token is injected very early so the `components` array\n    // isn't populated yet.\n    // 2. Find the root `LView` through the current `LView` - renderers are a prerequisite to\n    // creating the `LView`. This means that no `LView` will have been entered when this factory is\n    // invoked for the root component.\n    // 3. Have the token factory return `() => string` which is invoked when a nonce is requested -\n    // the slightly later execution does allow us to get an `LView` reference, but the fact that\n    // it is a function means that it could be executed at *any* time (including immediately) which\n    // may lead to weird bugs.\n    // 4. Have the `ComponentFactory` read the attribute and provide it to the injector under the\n    // hood - has the same problem as #1 and #2 in that the renderer is used to query for the root\n    // node and the nonce value needs to be available when the renderer is created.\n    return getDocument().body?.querySelector('[ngCspNonce]')?.getAttribute('ngCspNonce') || null;\n  },\n});\n\n/**\n * A configuration object for the image-related options. Contains:\n * - breakpoints: An array of integer breakpoints used to generate\n *      srcsets for responsive images.\n * - disableImageSizeWarning: A boolean value. Setting this to true will\n *      disable console warnings about oversized images.\n * - disableImageLazyLoadWarning: A boolean value. Setting this to true will\n *      disable console warnings about LCP images configured with `loading=\"lazy\"`.\n * Learn more about the responsive image configuration in [the NgOptimizedImage\n * guide](guide/image-directive).\n * Learn more about image warning options in [the related error page](errors/NG0913).\n * @publicApi\n */\nexport type ImageConfig = {\n  breakpoints?: number[],\n  placeholderResolution?: number,\n  disableImageSizeWarning?: boolean,\n  disableImageLazyLoadWarning?: boolean,\n};\n\nexport const IMAGE_CONFIG_DEFAULTS: ImageConfig = {\n  breakpoints: [16, 32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],\n  placeholderResolution: 30,\n  disableImageSizeWarning: false,\n  disableImageLazyLoadWarning: false,\n};\n\n/**\n * Injection token that configures the image optimized image functionality.\n * See {@link ImageConfig} for additional information about parameters that\n * can be used.\n *\n * @see {@link NgOptimizedImage}\n * @see {@link ImageConfig}\n * @publicApi\n */\nexport const IMAGE_CONFIG = new InjectionToken<ImageConfig>(\n    ngDevMode ? 'ImageConfig' : '', {providedIn: 'root', factory: () => IMAGE_CONFIG_DEFAULTS});\n"]}

package/esm2022/src/authoring/input/input.mjs

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { createInputSignal } from './input_signal';
+import { REQUIRED_UNSET_VALUE } from './input_signal_node';
+export function inputFunction(initialValue, opts) {
+    return createInputSignal(initialValue, opts);
+}
+export function inputRequiredFunction(opts) {
+    return createInputSignal(REQUIRED_UNSET_VALUE, opts);
+}
+/**
+ * The `input` function allows declaration of inputs in directives and
+ * components.
+ *
+ * Initializes an input with an initial value. If no explicit value
+ * is specified, Angular will use `undefined`.
+ *
+ * Consider using `input.required` for inputs that don't need an
+ * initial value.
+ *
+ * @usageNotes
+ * Initialize an input in your directive or component by declaring a
+ * class field and initializing it with the `input()` function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = input<string>();            // string|undefined
+ *   lastName = input.required<string>();    // string
+ *   age = input(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export const input = (() => {
+    // Note: This may be considered a side-effect, but nothing will depend on
+    // this assignment, unless this `input` constant export is accessed. It's a
+    // self-contained side effect that is local to the user facing`input` export.
+    inputFunction.required = inputRequiredFunction;
+    return inputFunction;
+})();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9hdXRob3JpbmcvaW5wdXQvaW5wdXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLGlCQUFpQixFQUErRyxNQUFNLGdCQUFnQixDQUFDO0FBQy9KLE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBRXpELE1BQU0sVUFBVSxhQUFhLENBQ3pCLFlBQW9CLEVBQ3BCLElBQWtDO0lBQ3BDLE9BQU8saUJBQWlCLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxDQUFDO0FBQy9DLENBQUM7QUFFRCxNQUFNLFVBQVUscUJBQXFCLENBQWdCLElBQWtDO0lBRXJGLE9BQU8saUJBQWlCLENBQUMsb0JBQTZCLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDaEUsQ0FBQztBQXdERDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBd0JHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFrQixDQUFDLEdBQUcsRUFBRTtJQUN4Qyx5RUFBeUU7SUFDekUsMkVBQTJFO0lBQzNFLDZFQUE2RTtJQUM1RSxhQUFxQixDQUFDLFFBQVEsR0FBRyxxQkFBcUIsQ0FBQztJQUN4RCxPQUFPLGFBQWdGLENBQUM7QUFDMUYsQ0FBQyxDQUFDLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2NyZWF0ZUlucHV0U2lnbmFsLCBJbnB1dE9wdGlvbnMsIElucHV0T3B0aW9uc1dpdGhvdXRUcmFuc2Zvcm0sIElucHV0T3B0aW9uc1dpdGhUcmFuc2Zvcm0sIElucHV0U2lnbmFsLCBJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm19IGZyb20gJy4vaW5wdXRfc2lnbmFsJztcbmltcG9ydCB7UkVRVUlSRURfVU5TRVRfVkFMVUV9IGZyb20gJy4vaW5wdXRfc2lnbmFsX25vZGUnO1xuXG5leHBvcnQgZnVuY3Rpb24gaW5wdXRGdW5jdGlvbjxSZWFkVCwgV3JpdGVUPihcbiAgICBpbml0aWFsVmFsdWU/OiBSZWFkVCxcbiAgICBvcHRzPzogSW5wdXRPcHRpb25zPFJlYWRULCBXcml0ZVQ+KTogSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtPFJlYWRUfHVuZGVmaW5lZCwgV3JpdGVUPiB7XG4gIHJldHVybiBjcmVhdGVJbnB1dFNpZ25hbChpbml0aWFsVmFsdWUsIG9wdHMpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaW5wdXRSZXF1aXJlZEZ1bmN0aW9uPFJlYWRULCBXcml0ZVQ+KG9wdHM/OiBJbnB1dE9wdGlvbnM8UmVhZFQsIFdyaXRlVD4pOlxuICAgIElucHV0U2lnbmFsV2l0aFRyYW5zZm9ybTxSZWFkVCwgV3JpdGVUPiB7XG4gIHJldHVybiBjcmVhdGVJbnB1dFNpZ25hbChSRVFVSVJFRF9VTlNFVF9WQUxVRSBhcyBuZXZlciwgb3B0cyk7XG59XG5cbi8qKlxuICogVGhlIGBpbnB1dGAgZnVuY3Rpb24gYWxsb3dzIGRlY2xhcmF0aW9uIG9mIGlucHV0cyBpbiBkaXJlY3RpdmVzIGFuZFxuICogY29tcG9uZW50cy5cbiAqXG4gKiBUaGUgZnVuY3Rpb24gZXhwb3NlcyBhbiBBUEkgZm9yIGFsc28gZGVjbGFyaW5nIHJlcXVpcmVkIGlucHV0cyB2aWEgdGhlXG4gKiBgaW5wdXQucmVxdWlyZWRgIGZ1bmN0aW9uLlxuICpcbiAqIEB1c2FnZU5vdGVzXG4gKiBJbml0aWFsaXplIGFuIGlucHV0IGluIHlvdXIgZGlyZWN0aXZlIG9yIGNvbXBvbmVudCBieSBkZWNsYXJpbmcgYVxuICogY2xhc3MgZmllbGQgYW5kIGluaXRpYWxpemluZyBpdCB3aXRoIHRoZSBgaW5wdXQoKWAgb3IgYGlucHV0LnJlcXVpcmVkKClgXG4gKiBmdW5jdGlvbi5cbiAqXG4gKiBgYGB0c1xuICogQERpcmVjdGl2ZSh7Li59KVxuICogZXhwb3J0IGNsYXNzIE15RGlyIHtcbiAqICAgZmlyc3ROYW1lID0gaW5wdXQ8c3RyaW5nPigpOyAgICAgICAgICAgIC8vIHN0cmluZ3x1bmRlZmluZWRcbiAqICAgbGFzdE5hbWUgPSBpbnB1dC5yZXF1aXJlZDxzdHJpbmc+KCk7ICAgIC8vIHN0cmluZ1xuICogICBhZ2UgPSBpbnB1dCgwKTsgICAgICAgICAgICAgICAgICAgICAgICAgLy8gbnVtYmVyXG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgaW50ZXJmYWNlIElucHV0RnVuY3Rpb24ge1xuICAvKipcbiAgICogSW5pdGlhbGl6ZXMgYW4gaW5wdXQgd2l0aCBhbiBpbml0aWFsIHZhbHVlLiBJZiBubyBleHBsaWNpdCB2YWx1ZVxuICAgKiBpcyBzcGVjaWZpZWQsIEFuZ3VsYXIgd2lsbCB1c2UgYHVuZGVmaW5lZGAuXG4gICAqXG4gICAqIENvbnNpZGVyIHVzaW5nIGBpbnB1dC5yZXF1aXJlZGAgZm9yIGlucHV0cyB0aGF0IGRvbid0IG5lZWQgYW5cbiAgICogaW5pdGlhbCB2YWx1ZS5cbiAgICpcbiAgICogQGRldmVsb3BlclByZXZpZXdcbiAgICovXG4gIDxSZWFkVD4oKTogSW5wdXRTaWduYWw8UmVhZFR8dW5kZWZpbmVkPjtcbiAgPFJlYWRUPihpbml0aWFsVmFsdWU6IFJlYWRULCBvcHRzPzogSW5wdXRPcHRpb25zV2l0aG91dFRyYW5zZm9ybTxSZWFkVD4pOiBJbnB1dFNpZ25hbDxSZWFkVD47XG4gIDxSZWFkVCwgV3JpdGVUPihpbml0aWFsVmFsdWU6IFJlYWRULCBvcHRzOiBJbnB1dE9wdGlvbnNXaXRoVHJhbnNmb3JtPFJlYWRULCBXcml0ZVQ+KTpcbiAgICAgIElucHV0U2lnbmFsV2l0aFRyYW5zZm9ybTxSZWFkVCwgV3JpdGVUPjtcblxuICAvKipcbiAgICogSW5pdGlhbGl6ZXMgYSByZXF1aXJlZCBpbnB1dC5cbiAgICpcbiAgICogVXNlcnMgb2YgeW91ciBkaXJlY3RpdmUvY29tcG9uZW50IG5lZWQgdG8gYmluZCB0byB0aGlzXG4gICAqIGlucHV0LiBJZiB1bnNldCwgYSBjb21waWxlIHRpbWUgZXJyb3Igd2lsbCBiZSByZXBvcnRlZC5cbiAgICpcbiAgICogQGRldmVsb3BlclByZXZpZXdcbiAgICovXG4gIHJlcXVpcmVkOiB7XG4gICAgPFJlYWRUPihvcHRzPzogSW5wdXRPcHRpb25zV2l0aG91dFRyYW5zZm9ybTxSZWFkVD4pOiBJbnB1dFNpZ25hbDxSZWFkVD47XG5cbiAgICA8UmVhZFQsIFdyaXRlVD4ob3B0czogSW5wdXRPcHRpb25zV2l0aFRyYW5zZm9ybTxSZWFkVCwgV3JpdGVUPik6XG4gICAgICAgIElucHV0U2lnbmFsV2l0aFRyYW5zZm9ybTxSZWFkVCwgV3JpdGVUPjtcbiAgfTtcbn1cblxuLyoqXG4gKiBUaGUgYGlucHV0YCBmdW5jdGlvbiBhbGxvd3MgZGVjbGFyYXRpb24gb2YgaW5wdXRzIGluIGRpcmVjdGl2ZXMgYW5kXG4gKiBjb21wb25lbnRzLlxuICpcbiAqIEluaXRpYWxpemVzIGFuIGlucHV0IHdpdGggYW4gaW5pdGlhbCB2YWx1ZS4gSWYgbm8gZXhwbGljaXQgdmFsdWVcbiAqIGlzIHNwZWNpZmllZCwgQW5ndWxhciB3aWxsIHVzZSBgdW5kZWZpbmVkYC5cbiAqXG4gKiBDb25zaWRlciB1c2luZyBgaW5wdXQucmVxdWlyZWRgIGZvciBpbnB1dHMgdGhhdCBkb24ndCBuZWVkIGFuXG4gKiBpbml0aWFsIHZhbHVlLlxuICpcbiAqIEB1c2FnZU5vdGVzXG4gKiBJbml0aWFsaXplIGFuIGlucHV0IGluIHlvdXIgZGlyZWN0aXZlIG9yIGNvbXBvbmVudCBieSBkZWNsYXJpbmcgYVxuICogY2xhc3MgZmllbGQgYW5kIGluaXRpYWxpemluZyBpdCB3aXRoIHRoZSBgaW5wdXQoKWAgZnVuY3Rpb24uXG4gKlxuICogYGBgdHNcbiAqIEBEaXJlY3RpdmUoey4ufSlcbiAqIGV4cG9ydCBjbGFzcyBNeURpciB7XG4gKiAgIGZpcnN0TmFtZSA9IGlucHV0PHN0cmluZz4oKTsgICAgICAgICAgICAvLyBzdHJpbmd8dW5kZWZpbmVkXG4gKiAgIGxhc3ROYW1lID0gaW5wdXQucmVxdWlyZWQ8c3RyaW5nPigpOyAgICAvLyBzdHJpbmdcbiAqICAgYWdlID0gaW5wdXQoMCk7ICAgICAgICAgICAgICAgICAgICAgICAgIC8vIG51bWJlclxuICogfVxuICogYGBgXG4gKlxuICogQGRldmVsb3BlclByZXZpZXdcbiAqL1xuZXhwb3J0IGNvbnN0IGlucHV0OiBJbnB1dEZ1bmN0aW9uID0gKCgpID0+IHtcbiAgLy8gTm90ZTogVGhpcyBtYXkgYmUgY29uc2lkZXJlZCBhIHNpZGUtZWZmZWN0LCBidXQgbm90aGluZyB3aWxsIGRlcGVuZCBvblxuICAvLyB0aGlzIGFzc2lnbm1lbnQsIHVubGVzcyB0aGlzIGBpbnB1dGAgY29uc3RhbnQgZXhwb3J0IGlzIGFjY2Vzc2VkLiBJdCdzIGFcbiAgLy8gc2VsZi1jb250YWluZWQgc2lkZSBlZmZlY3QgdGhhdCBpcyBsb2NhbCB0byB0aGUgdXNlciBmYWNpbmdgaW5wdXRgIGV4cG9ydC5cbiAgKGlucHV0RnVuY3Rpb24gYXMgYW55KS5yZXF1aXJlZCA9IGlucHV0UmVxdWlyZWRGdW5jdGlvbjtcbiAgcmV0dXJuIGlucHV0RnVuY3Rpb24gYXMgKHR5cGVvZiBpbnB1dEZ1bmN0aW9uJntyZXF1aXJlZDogdHlwZW9mIGlucHV0UmVxdWlyZWRGdW5jdGlvbn0pO1xufSkoKTtcbiJdfQ==

package/esm2022/src/authoring/input/input_signal.mjs

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { producerAccessed, SIGNAL } from '@angular/core/primitives/signals';
+import { RuntimeError } from '../../errors';
+import { INPUT_SIGNAL_NODE, REQUIRED_UNSET_VALUE } from './input_signal_node';
+export const ɵINPUT_SIGNAL_BRAND_READ_TYPE = /* @__PURE__ */ Symbol();
+export const ɵINPUT_SIGNAL_BRAND_WRITE_TYPE = /* @__PURE__ */ Symbol();
+/**
+ * Creates an input signal.
+ *
+ * @param initialValue The initial value.
+ *   Can be set to {@link REQUIRED_UNSET_VALUE} for required inputs.
+ * @param options Additional options for the input. e.g. a transform, or an alias.
+ */
+export function createInputSignal(initialValue, options) {
+    const node = Object.create(INPUT_SIGNAL_NODE);
+    node.value = initialValue;
+    // Perf note: Always set `transformFn` here to ensure that `node` always
+    // has the same v8 class shape, allowing monomorphic reads on input signals.
+    node.transformFn = options?.transform;
+    function inputValueFn() {
+        // Record that someone looked at this signal.
+        producerAccessed(node);
+        if (node.value === REQUIRED_UNSET_VALUE) {
+            throw new RuntimeError(-950 /* RuntimeErrorCode.REQUIRED_INPUT_NO_VALUE */, ngDevMode && 'Input is required but no value is available yet.');
+        }
+        return node.value;
+    }
+    inputValueFn[SIGNAL] = node;
+    if (ngDevMode) {
+        inputValueFn.toString = () => `[Input Signal: ${inputValueFn()}]`;
+    }
+    return inputValueFn;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/input/input_signal_node.mjs

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { SIGNAL_NODE, signalSetFn } from '@angular/core/primitives/signals';
+export const REQUIRED_UNSET_VALUE = /* @__PURE__ */ Symbol('InputSignalNode#UNSET');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+export const INPUT_SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...SIGNAL_NODE,
+        transformFn: undefined,
+        applyValueToInputSignal(node, value) {
+            signalSetFn(node, value);
+        }
+    };
+})();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/input/input_type_checking.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXRfdHlwZV9jaGVja2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2F1dGhvcmluZy9pbnB1dC9pbnB1dF90eXBlX2NoZWNraW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0lucHV0U2lnbmFsV2l0aFRyYW5zZm9ybX0gZnJvbSAnLi9pbnB1dF9zaWduYWwnO1xuXG4vKiogUmV0cmlldmVzIHRoZSBgV3JpdGVUYCBvZiBhbiBgSW5wdXRTaWduYWxgIGFuZCBgSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtYC4gKi9cbmV4cG9ydCB0eXBlIMm1VW53cmFwSW5wdXRTaWduYWxXcml0ZVR5cGU8RmllbGQ+ID1cbiAgICBGaWVsZCBleHRlbmRzIElucHV0U2lnbmFsV2l0aFRyYW5zZm9ybTx1bmtub3duLCBpbmZlciBXcml0ZVQ+PyBXcml0ZVQgOiBuZXZlcjtcblxuLyoqXG4gKiBVbndyYXBzIGFsbCBgSW5wdXRTaWduYWxgL2BJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm1gIGNsYXNzIGZpZWxkcyBvZlxuICogdGhlIGdpdmVuIGRpcmVjdGl2ZS5cbiAqL1xuZXhwb3J0IHR5cGUgybVVbndyYXBEaXJlY3RpdmVTaWduYWxJbnB1dHM8RGlyLCBGaWVsZHMgZXh0ZW5kcyBrZXlvZiBEaXI+ID0ge1xuICBbUCBpbiBGaWVsZHNdOiDJtVVud3JhcElucHV0U2lnbmFsV3JpdGVUeXBlPERpcltQXT5cbn07XG4iXX0=

package/esm2022/src/authoring/model/model.mjs

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { createModelSignal } from './model_signal';
+import { REQUIRED_UNSET_VALUE } from './model_signal_node';
+export function modelFunction(initialValue) {
+    return createModelSignal(initialValue);
+}
+export function modelRequiredFunction() {
+    return createModelSignal(REQUIRED_UNSET_VALUE);
+}
+/**
+ * `model` declares a writeable signal that is exposed as an input/output pair on the containing
+ * directive. The input name is taken either from the class member or from the `alias` option.
+ * The output name is generated by taking the input name and appending `Change`.
+ *
+ * Initializes a model with an initial value. If no explicit value
+ * is specified, Angular will use `undefined`.
+ *
+ * Consider using `model.required` for models that don't need an
+ * initial value.
+ *
+ * @usageNotes
+ * Initialize a model in your directive or component by declaring a
+ * class field and initializing it with the `model()` or `model.required()`
+ * function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = model<string>();            // string|undefined
+ *   lastName = model.required<string>();    // string
+ *   age = model(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export const model = (() => {
+    // Note: This may be considered a side-effect, but nothing will depend on
+    // this assignment, unless this `model` constant export is accessed. It's a
+    // self-contained side effect that is local to the user facing `model` export.
+    modelFunction.required = modelRequiredFunction;
+    return modelFunction;
+})();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/model/model_signal.mjs

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { producerAccessed, SIGNAL, signalSetFn } from '@angular/core/primitives/signals';
+import { RuntimeError } from '../../errors';
+import { ɵINPUT_SIGNAL_BRAND_READ_TYPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE } from '../input/input_signal';
+import { MODEL_SIGNAL_NODE, REQUIRED_UNSET_VALUE } from './model_signal_node';
+/**
+ * Creates a model signal.
+ *
+ * @param initialValue The initial value.
+ *   Can be set to {@link REQUIRED_UNSET_VALUE} for required model signals.
+ * @param options Additional options for the model.
+ */
+export function createModelSignal(initialValue) {
+    const subscriptions = [];
+    const node = Object.create(MODEL_SIGNAL_NODE);
+    node.value = initialValue;
+    function getter() {
+        producerAccessed(node);
+        assertModelSet(node.value);
+        return node.value;
+    }
+    function notifySubscribers(value) {
+        for (let i = 0; i < subscriptions.length; i++) {
+            subscriptions[i](value);
+        }
+    }
+    getter[SIGNAL] = node;
+    getter.asReadonly = (() => getter());
+    getter.set = (newValue) => {
+        if (!node.equal(node.value, newValue)) {
+            signalSetFn(node, newValue);
+            notifySubscribers(newValue);
+        }
+    };
+    getter.update = (updateFn) => {
+        assertModelSet(node.value);
+        getter.set(updateFn(node.value));
+    };
+    getter.subscribe = (callback) => {
+        subscriptions.push(callback);
+        // TODO(crisbeto): figure out if we can get rid of the object literal.
+        return {
+            unsubscribe: () => {
+                const index = subscriptions.indexOf(callback);
+                if (index > -1) {
+                    subscriptions.splice(index, 1);
+                }
+            }
+        };
+    };
+    if (ngDevMode) {
+        getter.toString = () => `[Model Signal: ${getter()}]`;
+    }
+    return getter;
+}
+/** Asserts that a model's value is set. */
+function assertModelSet(value) {
+    if (value === REQUIRED_UNSET_VALUE) {
+        throw new RuntimeError(-952 /* RuntimeErrorCode.REQUIRED_MODEL_NO_VALUE */, ngDevMode && 'Model is required but no value is available yet.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/model/model_signal_node.mjs

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { SIGNAL_NODE, signalSetFn } from '@angular/core/primitives/signals';
+export const REQUIRED_UNSET_VALUE = /* @__PURE__ */ Symbol('ModelSignalNode#UNSET');
+// Note: Using an IIFE here to ensure that the spread assignment is not considered
+// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.
+// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.
+export const MODEL_SIGNAL_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...SIGNAL_NODE,
+        // TODO(crisbeto): figure out how to avoid this.
+        // Maybe set an input flag that the value is writeable?
+        applyValueToInputSignal: (node, value) => signalSetFn(node, value)
+    };
+})();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/output.mjs

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { EventEmitter } from '../event_emitter';
+/**
+ * The `outputs` function allows declaration of outputs in directives and
+ * components.
+ *
+ * Initializes an output that can emit values to consumers of your
+ * directive/component.
+ *
+ * @usageNotes
+ * Initialize an output in your directive by declaring a
+ * class field and initializing it with the `output()` function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   nameChange = output<string>();     // OutputEmitter<string>
+ *   onClick = output();                // OutputEmitter<void>
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export function output(opts) {
+    return new EventEmitter();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/queries.mjs

@@ -5,11 +5,12 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import { createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn } from '../render3/query_reactive';
 function viewChildFn(locator, opts) {
-    return null;
+    return createSingleResultOptionalQuerySignalFn();
 }
 function viewChildRequiredFn(locator, opts) {
-    return null;
+    return createSingleResultRequiredQuerySignalFn();
 }
 /**
  * Initializes a view child query.
@@ -57,13 +58,13 @@ export const viewChild = (() => {
  * ```
  */
 export function viewChildren(locator, opts) {
-    return null;
+    return createMultiResultQuerySignalFn();
 }
 export function contentChildFn(locator, opts) {
-    return null;
+    return createSingleResultOptionalQuerySignalFn();
 }
 function contentChildRequiredFn(locator, opts) {
-    return null;
+    return createSingleResultRequiredQuerySignalFn();
 }
 /**
  * Initializes a content child query. Consider using `contentChild.required` for queries that should
@@ -108,6 +109,6 @@ export const contentChild = (() => {
  * ```
  */
 export function contentChildren(locator, opts) {
-    return null;
+    return createMultiResultQuerySignalFn();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/authoring/queries.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,SAAS,WAAW,CAChB,OAAuC,EACvC,IAAoC;IACtC,OAAO,IAAgC,CAAC;AAC1C,CAAC;AAED,SAAS,mBAAmB,CACxB,OAAuC,EAAE,IAAoC;IAC/E,OAAO,IAAsB,CAAC;AAChC,CAAC;AA0DD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,CAAC,GAAG,EAAE;IAChD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,WAAmB,CAAC,QAAQ,GAAG,mBAAmB,CAAC;IACpD,OAAO,WAA0E,CAAC;AACpF,CAAC,CAAC,EAAE,CAAC;AAQL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CACxB,OAAuC,EACvC,IAAoC;IACtC,OAAO,IAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,IAAK,CAAC;AACf,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,IAAK,CAAC;AACf,CAAC;AA4DD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,CAAC,GAAG,EAAE;IACtD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,cAAsB,CAAC,QAAQ,GAAG,sBAAsB,CAAC;IAC1D,OAAO,cAAmF,CAAC;AAC7F,CAAC,CAAC,EAAE,CAAC;AAUL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,IAAK,CAAC;AACf,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ProviderToken} from '../di';\nimport {Signal} from '../render3/reactivity/api';\n\nfunction viewChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  return null! as Signal<ReadT|undefined>;\n}\n\nfunction viewChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string, opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  return null! as Signal<ReadT>;\n}\n\n/**\n * Type of the `viewChild` function. The viewChild function creates a singular view query.\n *\n * It is a special function that also provides access to required query results via the `.required`\n * property.\n *\n * @developerPreview\n */\nexport interface ViewChildFunction {\n  /**\n   * Initializes a view child query. Consider using `viewChild.required` for queries that should\n   * always match.\n   *\n   * @usageNotes\n   * Create a child query in your component by declaring a\n   * class field and initializing it with the `viewChild()` function.\n   *\n   * ```ts\n   * @Component({template: '<div #el></div><my-component #cmp />'})\n   * export class TestComponent {\n   *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n   *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n   * }\n   * ```\n   *\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n      Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a view child query that is expected to always match an element.\n   *\n   * @usageNotes\n   * Create a required child query in your component by declaring a\n   * class field and initializing it with the `viewChild()` function.\n   *\n   * ```ts\n   * @Component({template: '<div #el></div><my-component #cmp />'})\n   * export class TestComponent {\n   *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n   *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n   * }\n   * ```\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n        Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a view child query.\n *\n * Consider using `viewChild.required` for queries that should always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `viewChild()` function.\n *\n * ```ts\n * @Component({template: '<div #el></div><my-component #cmp />'})\n * export class TestComponent {\n *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n * }\n * ```\n *\n * @developerPreview\n */\nexport const viewChild: ViewChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (viewChildFn as any).required = viewChildRequiredFn;\n  return viewChildFn as (typeof viewChildFn&{required: typeof viewChildRequiredFn});\n})();\n\nexport function viewChildren<LocatorT>(locator: ProviderToken<LocatorT>|\n                                       string): Signal<ReadonlyArray<LocatorT>>;\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a view children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `viewChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return null!;\n}\n\nexport function contentChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  return null!;\n}\n\nfunction contentChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  return null!;\n}\n\n/**\n * Type of the `contentChild` function.\n *\n * The contentChild function creates a singular content query. It is a special function that also\n * provides access to required query results via the `.required` property.\n *\n * @developerPreview\n */\nexport interface ContentChildFunction {\n  /**\n   * Initializes a content child query.\n   *\n   * Consider using `contentChild.required` for queries that should always match.\n   *\n   * @usageNotes\n   * Create a child query in your component by declaring a\n   * class field and initializing it with the `contentChild()` function.\n   *\n   * ```ts\n   * @Component({...})\n   * export class TestComponent {\n   *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n   *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n   * }\n   * ```\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {descendants?: boolean}):\n      Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {\n    descendants?: boolean, read: ProviderToken<ReadT>\n  }): Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a content child query that is always expected to match.\n   *\n   * @usageNotes\n   * Create a child query in your component by declaring a\n   * class field and initializing it with the `contentChild()` function.\n   *\n   * ```ts\n   * @Component({...})\n   * export class TestComponent {\n   *   headerElElRequired = contentChild.required<ElementRef>('h');   // Signal<ElementRef>\n   *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n   * }\n   * ```\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {descendants?: boolean}):\n        Signal<LocatorT>;\n    <LocatorT, ReadT>(\n        locator: ProviderToken<LocatorT>|string,\n        opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a content child query. Consider using `contentChild.required` for queries that should\n * always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `contentChild()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>\n *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n * }\n * ```\n */\nexport const contentChild: ContentChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (contentChildFn as any).required = contentChildRequiredFn;\n  return contentChildFn as (typeof contentChildFn&{required: typeof contentChildRequiredFn});\n})();\n\n\nexport function contentChildren<LocatorT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean}): Signal<ReadonlyArray<LocatorT>>;\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a content children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `contentChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return null!;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/authoring/queries.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAC,8BAA8B,EAAE,uCAAuC,EAAE,uCAAuC,EAAC,MAAM,2BAA2B,CAAC;AAG3J,SAAS,WAAW,CAChB,OAAuC,EACvC,IAAoC;IACtC,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,mBAAmB,CACxB,OAAuC,EAAE,IAAoC;IAC/E,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAkCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,CAAC,GAAG,EAAE;IAChD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,WAAmB,CAAC,QAAQ,GAAG,mBAAmB,CAAC;IACpD,OAAO,WAA0E,CAAC;AACpF,CAAC,CAAC,EAAE,CAAC;AAQL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CACxB,OAAuC,EACvC,IAAoC;IACtC,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,CAAC,GAAG,EAAE;IACtD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,cAAsB,CAAC,QAAQ,GAAG,sBAAsB,CAAC;IAC1D,OAAO,cAAmF,CAAC;AAC7F,CAAC,CAAC,EAAE,CAAC;AAUL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ProviderToken} from '../di/provider_token';\nimport {createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn} from '../render3/query_reactive';\nimport {Signal} from '../render3/reactivity/api';\n\nfunction viewChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction viewChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string, opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `viewChild` function. The viewChild function creates a singular view query.\n *\n * It is a special function that also provides access to required query results via the `.required`\n * property.\n *\n * @developerPreview\n */\nexport interface ViewChildFunction {\n  /**\n   * Initializes a view child query. Consider using `viewChild.required` for queries that should\n   * always match.\n   *\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n      Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a view child query that is expected to always match an element.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n        Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a view child query.\n *\n * Consider using `viewChild.required` for queries that should always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `viewChild()` function.\n *\n * ```ts\n * @Component({template: '<div #el></div><my-component #cmp />'})\n * export class TestComponent {\n *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n * }\n * ```\n *\n * @developerPreview\n */\nexport const viewChild: ViewChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (viewChildFn as any).required = viewChildRequiredFn;\n  return viewChildFn as (typeof viewChildFn&{required: typeof viewChildRequiredFn});\n})();\n\nexport function viewChildren<LocatorT>(locator: ProviderToken<LocatorT>|\n                                       string): Signal<ReadonlyArray<LocatorT>>;\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a view children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `viewChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n\nexport function contentChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction contentChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `contentChild` function.\n *\n * The contentChild function creates a singular content query. It is a special function that also\n * provides access to required query results via the `.required` property.\n *\n * @developerPreview\n */\nexport interface ContentChildFunction {\n  /**\n   * Initializes a content child query.\n   *\n   * Consider using `contentChild.required` for queries that should always match.\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n    descendants?: boolean,\n    read?: undefined\n  }): Signal<LocatorT|undefined>;\n\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {\n    descendants?: boolean, read: ProviderToken<ReadT>\n  }): Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a content child query that is always expected to match.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n      descendants?: boolean,\n      read?: undefined,\n    }): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(\n        locator: ProviderToken<LocatorT>|string,\n        opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a content child query. Consider using `contentChild.required` for queries that should\n * always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `contentChild()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>\n *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n * }\n * ```\n */\nexport const contentChild: ContentChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (contentChildFn as any).required = contentChildRequiredFn;\n  return contentChildFn as (typeof contentChildFn&{required: typeof contentChildRequiredFn});\n})();\n\n\nexport function contentChildren<LocatorT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: undefined}): Signal<ReadonlyArray<LocatorT>>;\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a content children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `contentChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n"]}

package/esm2022/src/authoring.mjs

@@ -5,5 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export { ɵINPUT_SIGNAL_BRAND_WRITE_TYPE } from './authoring/input_signal';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvYXV0aG9yaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQU1ILE9BQU8sRUFBcUYsOEJBQThCLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vLyBOb3RlOiBgaW5wdXRgIGlzIGV4cG9ydGVkIGluIGBjb3JlLnRzYCBkdWUgdG86XG4vLyBodHRwczovL2RvY3MuZ29vZ2xlLmNvbS9kb2N1bWVudC9kLzFSWGIxd1l3c2JKb3RPMUtCZ1NEc0F0S3BkdUdtSUhvZDlBRHh1WGNBdlY0L2VkaXQ/dGFiPXQuMC5cblxuZXhwb3J0IHtJbnB1dEZ1bmN0aW9ufSBmcm9tICcuL2F1dGhvcmluZy9pbnB1dCc7XG5leHBvcnQge0lucHV0T3B0aW9ucywgSW5wdXRPcHRpb25zV2l0aG91dFRyYW5zZm9ybSwgSW5wdXRPcHRpb25zV2l0aFRyYW5zZm9ybSwgSW5wdXRTaWduYWwsIMm1SU5QVVRfU0lHTkFMX0JSQU5EX1dSSVRFX1RZUEV9IGZyb20gJy4vYXV0aG9yaW5nL2lucHV0X3NpZ25hbCc7XG5leHBvcnQge8m1VW53cmFwRGlyZWN0aXZlU2lnbmFsSW5wdXRzfSBmcm9tICcuL2F1dGhvcmluZy9pbnB1dF90eXBlX2NoZWNraW5nJztcbiJdfQ==
+export { ɵINPUT_SIGNAL_BRAND_WRITE_TYPE } from './authoring/input/input_signal';
+export { output as ɵoutput } from './authoring/output';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvYXV0aG9yaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQU1ILE9BQU8sRUFBK0csOEJBQThCLEVBQUMsTUFBTSxnQ0FBZ0MsQ0FBQztBQUk1TCxPQUFPLEVBQUMsTUFBTSxJQUFJLE9BQU8sRUFBbUUsTUFBTSxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vLyBOb3RlOiBgaW5wdXRgIGFuZCBgbW9kZWxgIGFyZSBleHBvcnRlZCBpbiBgY29yZS50c2AgZHVlIHRvOlxuLy8gaHR0cHM6Ly9kb2NzLmdvb2dsZS5jb20vZG9jdW1lbnQvZC8xUlhiMXdZd3NiSm90TzFLQmdTRHNBdEtwZHVHbUlIb2Q5QUR4dVhjQXZWNC9lZGl0P3RhYj10LjAuXG5cbmV4cG9ydCB7SW5wdXRGdW5jdGlvbn0gZnJvbSAnLi9hdXRob3JpbmcvaW5wdXQvaW5wdXQnO1xuZXhwb3J0IHtJbnB1dE9wdGlvbnMsIElucHV0T3B0aW9uc1dpdGhvdXRUcmFuc2Zvcm0sIElucHV0T3B0aW9uc1dpdGhUcmFuc2Zvcm0sIElucHV0U2lnbmFsLCBJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm0sIMm1SU5QVVRfU0lHTkFMX0JSQU5EX1dSSVRFX1RZUEV9IGZyb20gJy4vYXV0aG9yaW5nL2lucHV0L2lucHV0X3NpZ25hbCc7XG5leHBvcnQge8m1VW53cmFwRGlyZWN0aXZlU2lnbmFsSW5wdXRzfSBmcm9tICcuL2F1dGhvcmluZy9pbnB1dC9pbnB1dF90eXBlX2NoZWNraW5nJztcbmV4cG9ydCB7TW9kZWxGdW5jdGlvbn0gZnJvbSAnLi9hdXRob3JpbmcvbW9kZWwvbW9kZWwnO1xuZXhwb3J0IHtNb2RlbE9wdGlvbnMsIE1vZGVsU2lnbmFsfSBmcm9tICcuL2F1dGhvcmluZy9tb2RlbC9tb2RlbF9zaWduYWwnO1xuZXhwb3J0IHtvdXRwdXQgYXMgybVvdXRwdXQsIE91dHB1dEVtaXR0ZXIgYXMgybVPdXRwdXRFbWl0dGVyLCBPdXRwdXRPcHRpb25zIGFzIMm1T3V0cHV0T3B0aW9uc30gZnJvbSAnLi9hdXRob3Jpbmcvb3V0cHV0JztcbmV4cG9ydCB7Q29udGVudENoaWxkRnVuY3Rpb24sIFZpZXdDaGlsZEZ1bmN0aW9ufSBmcm9tICcuL2F1dGhvcmluZy9xdWVyaWVzJztcbiJdfQ==