init

node_modules/@angular/core/fesm2022/primitives/di.mjs

@@ -0,0 +1,23 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+export { NOT_FOUND, NotFoundError, getCurrentInjector, inject, isNotFound, setCurrentInjector } from '../not_found.mjs';
+
+function defineInjectable(opts) {
+    return {
+        token: opts.token,
+        providedIn: opts.providedIn || null,
+        factory: opts.factory,
+        value: undefined,
+    };
+}
+function registerInjectable(ctor, declaration) {
+    ctor.ɵprov = declaration;
+    return ctor;
+}
+
+export { defineInjectable, registerInjectable };
+//# sourceMappingURL=di.mjs.map

node_modules/@angular/core/fesm2022/primitives/di.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"di.mjs","sources":["../../../../../../k8-fastbuild-ST-199a4f3c4e20/bin/packages/core/primitives/di/src/injection_token.ts"],"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.dev/license\n */\n\nimport {Type} from './type';\n/**\n * Information about how a type or `InjectionToken` interfaces with the DI\n * system. This describes:\n *\n * 1. *How* the type is provided\n *    The declaration must specify only one of the following:\n *    - A `value` which is a predefined instance of the type.\n *    - A `factory` which defines how to create the given type `T`, possibly\n *      requesting injection of other types if necessary.\n *    - Neither, in which case the type is expected to already be present in the\n *      injector hierarchy. This is used for internal use cases.\n *\n * 2. *Where* the type is stored (if it is stored)\n *    - The `providedIn` parameter specifies which injector the type belongs to.\n *    - The `token` is used as the key to store the type in the injector.\n */\nexport interface ɵɵInjectableDeclaration<T> {\n  /**\n   * Specifies that the given type belongs to a particular `Injector`,\n   * `NgModule`, or a special scope (e.g. `'root'`).\n   *\n   * `any` is deprecated and will be removed soon.\n   *\n   * A value of `null` indicates that the injectable does not belong to any\n   * scope, and won't be stored in any injector. For declarations with a\n   * factory, this will create a new instance of the type each time it is\n   * requested.\n   */\n  providedIn: Type<any> | 'root' | 'platform' | 'any' | null;\n\n  /**\n   * The token to which this definition belongs.\n   *\n   * Note that this may not be the same as the type that the `factory` will create.\n   */\n  token: unknown;\n\n  /**\n   * Factory method to execute to create an instance of the injectable.\n   */\n  factory?: (t?: Type<any>) => T;\n\n  /**\n   * In a case of no explicit injector, a location where the instance of the injectable is stored.\n   */\n  value?: T;\n}\n\n/**\n * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.\n *\n * `InjectableType`s contain their own Dependency Injection metadata and are usable in an\n * `InjectorDef`-based `StaticInjector`.\n *\n * @publicApi\n */\nexport interface InjectionToken<T> {\n  ɵprov: ɵɵInjectableDeclaration<T>;\n}\n\nexport function defineInjectable<T>(opts: {\n  token: unknown;\n  providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;\n  factory: () => T;\n}): ɵɵInjectableDeclaration<T> {\n  return {\n    token: opts.token,\n    providedIn: (opts.providedIn as any) || null,\n    factory: opts.factory,\n    value: undefined,\n  } as ɵɵInjectableDeclaration<T>;\n}\n\nexport type Constructor<T> = Function & {prototype: T};\n\nexport function registerInjectable<T>(\n  ctor: unknown,\n  declaration: ɵɵInjectableDeclaration<T>,\n): InjectionToken<T> {\n  (ctor as unknown as InjectionToken<T>).ɵprov = declaration;\n  return ctor as Constructor<T> & InjectionToken<T>;\n}\n"],"names":[],"mappings":";;;;;;;;AAqEM,SAAU,gBAAgB,CAAI,IAInC,EAAA;IACC,OAAO;QACL,KAAK,EAAE,IAAI,CAAC,KAAK;AACjB,QAAA,UAAU,EAAG,IAAI,CAAC,UAAkB,IAAI,IAAI;QAC5C,OAAO,EAAE,IAAI,CAAC,OAAO;AACrB,QAAA,KAAK,EAAE,SAAS;KACa;AACjC;AAIgB,SAAA,kBAAkB,CAChC,IAAa,EACb,WAAuC,EAAA;AAEtC,IAAA,IAAqC,CAAC,KAAK,GAAG,WAAW;AAC1D,IAAA,OAAO,IAA0C;AACnD;;;;"}

node_modules/@angular/core/fesm2022/primitives/signals.mjs

@@ -0,0 +1,221 @@
+/**
+ * @license Angular v20.3.11
+ * (c) 2010-2025 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import { SIGNAL, consumerMarkDirty, REACTIVE_NODE, consumerDestroy, isInNotificationPhase, consumerPollProducersForChange, consumerBeforeComputation, consumerAfterComputation } from '../signal.mjs';
+export { SIGNAL_NODE, createComputed, createSignal, defaultEquals, finalizeConsumerAfterComputation, getActiveConsumer, isReactive, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, resetConsumerBeforeComputation, runPostProducerCreatedFn, runPostSignalSetFn, setActiveConsumer, setPostProducerCreatedFn, setPostSignalSetFn, setThrowInvalidWriteToSignalError, signalGetFn, signalSetFn, signalUpdateFn } from '../signal.mjs';
+export { BASE_EFFECT_NODE, createLinkedSignal, linkedSignalSetFn, linkedSignalUpdateFn, runEffect, untracked } from '../effect.mjs';
+export { setAlternateWeakRefImpl } from '../weak_ref.mjs';
+
+/**
+ * A custom formatter which renders signals in an easy-to-read format.
+ *
+ * @see https://firefox-source-docs.mozilla.org/devtools-user/custom_formatters/index.html
+ */
+const formatter = {
+    /**
+     *  If the function returns `null`, the formatter is not used for this reference
+     */
+    header: (sig, config) => {
+        if (!isSignal(sig) || config?.ngSkipFormatting)
+            return null;
+        let value;
+        try {
+            value = sig();
+        }
+        catch {
+            // In case the signl throws, we don't want to break the formatting.
+            return ['span', 'Signal(⚠️ Error)'];
+        }
+        const kind = 'computation' in sig[SIGNAL] ? 'Computed' : 'Signal';
+        const isPrimitive = value === null || (!Array.isArray(value) && typeof value !== 'object');
+        return [
+            'span',
+            {},
+            ['span', {}, `${kind}(`],
+            (() => {
+                if (isSignal(value)) {
+                    // Recursively call formatter. Could return an `object` to call the formatter through DevTools,
+                    // but then recursive signals will render multiple expando arrows which is an awkward UX.
+                    return formatter.header(value, config);
+                }
+                else if (isPrimitive && value !== undefined && typeof value !== 'function') {
+                    // Use built-in rendering for primitives which applies standard syntax highlighting / theming.
+                    // Can't do this for `undefined` however, as the browser thinks we forgot to provide an object.
+                    // Also don't want to do this for functions which render nested expando arrows.
+                    return ['object', { object: value }];
+                }
+                else {
+                    return prettifyPreview(value);
+                }
+            })(),
+            ['span', {}, `)`],
+        ];
+    },
+    hasBody: (sig, config) => {
+        if (!isSignal(sig))
+            return false;
+        try {
+            sig();
+        }
+        catch {
+            return false;
+        }
+        return !config?.ngSkipFormatting;
+    },
+    body: (sig, config) => {
+        // We can use sys colors to fit the current DevTools theme.
+        // Those are unfortunately only available on Chromium-based browsers.
+        // On Firefow we fall back to the default color
+        const color = 'var(--sys-color-primary)';
+        return [
+            'div',
+            { style: `background: #FFFFFF10; padding-left: 4px; padding-top: 2px; padding-bottom: 2px;` },
+            ['div', { style: `color: ${color}` }, 'Signal value: '],
+            ['div', { style: `padding-left: .5rem;` }, ['object', { object: sig(), config }]],
+            ['div', { style: `color: ${color}` }, 'Signal function: '],
+            [
+                'div',
+                { style: `padding-left: .5rem;` },
+                ['object', { object: sig, config: { ...config, skipFormatting: true } }],
+            ],
+        ];
+    },
+};
+function prettifyPreview(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return `Array(${value.length})`;
+    if (value instanceof Element)
+        return `<${value.tagName.toLowerCase()}>`;
+    if (value instanceof URL)
+        return `URL`;
+    switch (typeof value) {
+        case 'undefined': {
+            return 'undefined';
+        }
+        case 'function': {
+            if ('prototype' in value) {
+                // This is what Chrome renders, can't use `object` though because it creates a nested expando arrow.
+                return 'class';
+            }
+            else {
+                return '() => {…}';
+            }
+        }
+        case 'object': {
+            if (value.constructor.name === 'Object') {
+                return '{…}';
+            }
+            else {
+                return `${value.constructor.name} {}`;
+            }
+        }
+        default: {
+            return ['object', { object: value, config: { skipFormatting: true } }];
+        }
+    }
+}
+function isSignal(value) {
+    return value[SIGNAL] !== undefined;
+}
+/**
+ * Installs the custom formatter into custom formatting on Signals in the devtools.
+ *
+ * Supported by both Chrome and Firefox.
+ *
+ * @see https://firefox-source-docs.mozilla.org/devtools-user/custom_formatters/index.html
+ */
+function installDevToolsSignalFormatter() {
+    globalThis.devtoolsFormatters ??= [];
+    if (!globalThis.devtoolsFormatters.some((f) => f === formatter)) {
+        globalThis.devtoolsFormatters.push(formatter);
+    }
+}
+
+function createWatch(fn, schedule, allowSignalWrites) {
+    const node = Object.create(WATCH_NODE);
+    if (allowSignalWrites) {
+        node.consumerAllowSignalWrites = true;
+    }
+    node.fn = fn;
+    node.schedule = schedule;
+    const registerOnCleanup = (cleanupFn) => {
+        node.cleanupFn = cleanupFn;
+    };
+    function isWatchNodeDestroyed(node) {
+        return node.fn === null && node.schedule === null;
+    }
+    function destroyWatchNode(node) {
+        if (!isWatchNodeDestroyed(node)) {
+            consumerDestroy(node); // disconnect watcher from the reactive graph
+            node.cleanupFn();
+            // nullify references to the integration functions to mark node as destroyed
+            node.fn = null;
+            node.schedule = null;
+            node.cleanupFn = NOOP_CLEANUP_FN;
+        }
+    }
+    const run = () => {
+        if (node.fn === null) {
+            // trying to run a destroyed watch is noop
+            return;
+        }
+        if (isInNotificationPhase()) {
+            throw new Error(typeof ngDevMode !== 'undefined' && ngDevMode
+                ? 'Schedulers cannot synchronously execute watches while scheduling.'
+                : '');
+        }
+        node.dirty = false;
+        if (node.version > 0 && !consumerPollProducersForChange(node)) {
+            return;
+        }
+        node.version++;
+        const prevConsumer = consumerBeforeComputation(node);
+        try {
+            node.cleanupFn();
+            node.cleanupFn = NOOP_CLEANUP_FN;
+            node.fn(registerOnCleanup);
+        }
+        finally {
+            consumerAfterComputation(node, prevConsumer);
+        }
+    };
+    node.ref = {
+        notify: () => consumerMarkDirty(node),
+        run,
+        cleanup: () => node.cleanupFn(),
+        destroy: () => destroyWatchNode(node),
+        [SIGNAL]: node,
+    };
+    return node.ref;
+}
+const NOOP_CLEANUP_FN = () => { };
+// 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.
+const WATCH_NODE = /* @__PURE__ */ (() => {
+    return {
+        ...REACTIVE_NODE,
+        consumerIsAlwaysLive: true,
+        consumerAllowSignalWrites: false,
+        consumerMarkedDirty: (node) => {
+            if (node.schedule !== null) {
+                node.schedule(node.ref);
+            }
+        },
+        cleanupFn: NOOP_CLEANUP_FN,
+    };
+})();
+
+// We're using a top-level access to enable signal formatting whenever the signals package is loaded.
+if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+    // tslint:disable-next-line: no-toplevel-property-access
+    installDevToolsSignalFormatter();
+}
+
+export { REACTIVE_NODE, SIGNAL, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, createWatch, installDevToolsSignalFormatter, isInNotificationPhase };
+//# sourceMappingURL=signals.mjs.map