@lushly-dev/fast-element 3.0.1-preview.0 → 3.0.1-preview.2

package/dist/esm/hydration/messages.js

@@ -0,0 +1,84 @@
+/**
+ * Centralized hydration mismatch message strings used by both the default
+ * minimal `HydrationDiagnostic` and the opt-in `hydrationDebugger` rich
+ * formatter, and by the structural-error throw sites in
+ * `target-builder.ts`.
+ *
+ * Static text is exported as a plain `const`; interpolated text is exported
+ * as a small builder function. Plain `export const` declarations tree-shake
+ * better than frozen-object property bags, so unused strings drop out of
+ * bundles cleanly.
+ */
+/**
+ * Fallback host tag name used when a hydration mismatch is detected on a
+ * node that is not inside a shadow root.
+ */
+export const unknownHostName = "unknown";
+// -- Aspect labels (consumed by the opt-in hydrationDebugger) ----------------
+export const aspectLabelAttribute = "attribute";
+export const aspectLabelBooleanAttribute = "boolean attribute";
+export const aspectLabelProperty = "property";
+export const aspectLabelContent = "content";
+export const aspectLabelTokenList = "token list";
+export const aspectLabelEvent = "event";
+/** Fallback used when the aspectType is missing or unknown. */
+export const aspectLabelUnknown = "binding";
+/**
+ * Combines an aspect label with the original source aspect identifier from
+ * markup (e.g. `"property className"`). Returns the bare label when no
+ * source aspect was captured.
+ */
+export function formatAspect(label, sourceAspect) {
+    return sourceAspect ? `${label} \`${sourceAspect}\`` : label;
+}
+/**
+ * Formats the "Expected" half of the rich hydration mismatch message, e.g.
+ * `"<span> with content binding"` or `"content binding"` when no tag is
+ * associated with the binding factory.
+ */
+export function formatExpectedTarget(tagName, aspect) {
+    return tagName
+        ? `<${tagName.toLowerCase()}> with ${aspect} binding`
+        : `${aspect} binding`;
+}
+/**
+ * Default minimal hydration mismatch message used when the
+ * `hydrationDebugger` opt-in is not installed. The optional `detail` string
+ * carries the structural expectation surfaced by `target-builder.ts`.
+ */
+export function formatDefaultMismatchMessage(hostName, detail) {
+    const suffix = detail ? `: ${detail}` : "";
+    return (`Hydration mismatch in <${hostName}>${suffix}. Install ` +
+        `hydrationDebugger() from "@lushly-dev/fast-element/hydration.js" and ` +
+        `pass it as enableHydration({ debugger: hydrationDebugger() }) for an ` +
+        `"Expected / Received" report including the SSR HTML snippet.`);
+}
+/**
+ * Rich `Expected … / Received …` hydration mismatch message format produced
+ * by the `hydrationDebugger` formatter.
+ */
+export function formatRichMismatchMessage(hostName, expectedText, receivedHtml) {
+    return (`Hydration mismatch in <${hostName}>.\n` +
+        `  Expected: ${expectedText}\n` +
+        `  Received: ${receivedHtml}`);
+}
+// -- Structural expectations (used by target-builder.ts throw sites) ---------
+export const expectedContentAfterStartMarker = "content following `<!--fe:b-->` content binding marker";
+export const expectedContentEndMarker = "matching `<!--fe:/b-->` content binding close marker";
+export const expectedElementBoundaryEndMarker = "matching `<!--fe:/e-->` element boundary close marker";
+/**
+ * Builds the "no more attribute bindings" structural expectation message
+ * thrown when an element's `data-fe` count claims more attribute bindings
+ * than the compiled template defines.
+ */
+export function formatNoMoreAttributeBindings(factoryCount) {
+    return `no more attribute bindings (template defines ${factoryCount})`;
+}
+/**
+ * Builds the "no more content bindings" structural expectation message
+ * thrown when the SSR DOM contains more content binding markers than the
+ * compiled template defines.
+ */
+export function formatNoMoreContentBindings(factoryCount) {
+    return `no more content bindings (template defines ${factoryCount})`;
+}

package/dist/esm/hydration/runtime.js

@@ -0,0 +1,33 @@
+import { Hydratable } from "../components/hydration.js";
+import { ViewTemplate } from "../templating/template.js";
+import { HydrationView } from "../templating/hydration-view.js";
+let installed = false;
+/**
+ * Installs the hydration runtime on `ViewTemplate.prototype`,
+ * making all templates hydratable. Call this before any hydration
+ * occurs. Safe to call multiple times — subsequent calls are no-ops.
+ * @internal
+ */
+export function ensureHydrationRuntime() {
+    if (installed) {
+        return;
+    }
+    const prototype = ViewTemplate.prototype;
+    if (prototype[Hydratable] !== Hydratable) {
+        Object.defineProperties(prototype, {
+            [Hydratable]: {
+                value: Hydratable,
+                enumerable: false,
+                configurable: false,
+            },
+            hydrate: {
+                value(firstChild, lastChild, hostBindingTarget) {
+                    return new HydrationView(firstChild, lastChild, this, hostBindingTarget);
+                },
+                enumerable: true,
+                configurable: false,
+            },
+        });
+    }
+    installed = true;
+}

package/dist/esm/hydration/target-builder.js

@@ -0,0 +1,264 @@
+import { HydrationMarkup } from "../components/hydration.js";
+import { getHostName, getHydrationDiagnostic, } from "./diagnostics.js";
+import { expectedContentAfterStartMarker, expectedContentEndMarker, expectedElementBoundaryEndMarker, formatNoMoreAttributeBindings, formatNoMoreContentBindings, } from "./messages.js";
+export class HydrationTargetElementError extends Error {
+    constructor(
+    /**
+     * The error message
+     */
+    message, 
+    /**
+     * The Compiled View Behavior Factories that belong to the view.
+     */
+    factories, 
+    /**
+     * The node to target factory.
+     */
+    node, 
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply when the mismatch was detected. Free-form
+     * string for structural errors that do not correspond to a single
+     * binding factory.
+     */
+    expected, 
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point.
+     */
+    received) {
+        super(message);
+        this.factories = factories;
+        this.node = node;
+        this.expected = expected;
+        this.received = received;
+    }
+}
+function isComment(node) {
+    return node.nodeType === Node.COMMENT_NODE;
+}
+function isText(node) {
+    return node.nodeType === Node.TEXT_NODE;
+}
+/**
+ * Returns a range object inclusive of all nodes including and between the
+ * provided first and last node.
+ * @param first - The first node
+ * @param last - This last node
+ * @returns
+ */
+export function createRangeForNodes(first, last) {
+    const range = document.createRange();
+    range.setStart(first, 0);
+    // The lastIndex should be inclusive of the end of the lastChild. Obtain offset based
+    // on usageNotes:  https://developer.mozilla.org/en-US/docs/Web/API/Range/setEnd#usage_notes
+    range.setEnd(last, isComment(last) || isText(last) ? last.data.length : last.childNodes.length);
+    return range;
+}
+/**
+ * Maps compiled ViewBehaviorFactory IDs to their corresponding DOM nodes in the
+ * server-rendered shadow root. Uses a TreeWalker to scan the existing DOM between
+ * firstNode and lastNode, processing data-free sequential hydration markers.
+ *
+ * A sequential factory pointer advances through the factories array in DFS order.
+ * Since the template compiler and hydration walker both traverse the DOM in
+ * identical depth-first order, no embedded indices are needed in markers.
+ *
+ * For element nodes: parses `data-fe="N"` to determine the count of attribute
+ * binding factories, then consumes N factories sequentially.
+ *
+ * For comment nodes: `fe:b` markers consume the next factory for content bindings,
+ * using balanced depth counting for nested marker pairing. `fe:e` markers cause
+ * the walker to skip nested custom element subtrees.
+ *
+ * Host bindings (targetNodeId='h') appear at the start of the factories array but
+ * have no SSR markers — getHydrationIndexOffset() computes the initial pointer value.
+ *
+ * @param firstNode - The first node of the view.
+ * @param lastNode -  The last node of the view.
+ * @param factories - The Compiled View Behavior Factories that belong to the view.
+ * @returns - A {@link ViewBehaviorTargets } object for the factories in the view.
+ */
+export function buildViewBindingTargets(firstNode, lastNode, factories) {
+    const range = createRangeForNodes(firstNode, lastNode);
+    const treeRoot = range.commonAncestorContainer;
+    const walker = document.createTreeWalker(treeRoot, NodeFilter.SHOW_ELEMENT + NodeFilter.SHOW_COMMENT + NodeFilter.SHOW_TEXT, {
+        acceptNode(node) {
+            return range.comparePoint(node, 0) === 0
+                ? NodeFilter.FILTER_ACCEPT
+                : NodeFilter.FILTER_REJECT;
+        },
+    });
+    const targets = {};
+    const boundaries = {};
+    // Sequential factory pointer — skip host bindings at the start
+    const hydrationIndexOffset = getHydrationIndexOffset(factories);
+    let factoryPointer = hydrationIndexOffset;
+    let node = (walker.currentNode = firstNode);
+    while (node !== null) {
+        switch (node.nodeType) {
+            case Node.ELEMENT_NODE: {
+                const element = node;
+                const legacyIndices = HydrationMarkup.parseLegacyAttributeBindingIndices(element);
+                if (legacyIndices !== null) {
+                    for (const index of legacyIndices) {
+                        const factoryIndex = index + hydrationIndexOffset;
+                        const factory = factories[factoryIndex];
+                        if (!factory) {
+                            const expected = formatNoMoreAttributeBindings(factories.length);
+                            const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+                            throw new HydrationTargetElementError(result.message, factories, element, result.expected, result.received);
+                        }
+                        targetFactory(factory, node, targets);
+                        factoryPointer = Math.max(factoryPointer, factoryIndex + 1);
+                    }
+                    HydrationMarkup.removeLegacyAttributeBindingMarkers(element);
+                    break;
+                }
+                const count = HydrationMarkup.parseAttributeBindingCount(element);
+                if (count !== null) {
+                    for (let i = 0; i < count; i++) {
+                        const factory = factories[factoryPointer++];
+                        if (!factory) {
+                            const expected = formatNoMoreAttributeBindings(factories.length);
+                            const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+                            throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+                        }
+                        targetFactory(factory, node, targets);
+                    }
+                    element.removeAttribute(HydrationMarkup.attributeMarkerName);
+                }
+                break;
+            }
+            case Node.COMMENT_NODE: {
+                const data = node.data;
+                if (HydrationMarkup.isElementBoundaryStartMarker(node)) {
+                    // Element boundary — clear start marker and skip subtree
+                    node.data = "";
+                    skipToElementBoundaryEnd(walker, factories, node);
+                }
+                else if (HydrationMarkup.isContentBindingStartMarker(data)) {
+                    // Content binding — consume next factory
+                    const legacyIndex = HydrationMarkup.parseLegacyContentBindingStartIndex(data);
+                    const factoryIndex = legacyIndex === null
+                        ? factoryPointer++
+                        : legacyIndex + hydrationIndexOffset;
+                    const factory = factories[factoryIndex];
+                    factoryPointer = Math.max(factoryPointer, factoryIndex + 1);
+                    if (!factory) {
+                        const expected = formatNoMoreContentBindings(factories.length);
+                        const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+                        throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+                    }
+                    targetContentBinding(node, walker, factory, factories, targets, boundaries);
+                }
+                break;
+            }
+        }
+        node = walker.nextNode();
+    }
+    range.detach();
+    return { targets, boundaries };
+}
+function targetContentBinding(node, walker, factory, factories, targets, boundaries) {
+    const nodes = [];
+    let current = walker.nextSibling();
+    node.data = "";
+    if (current === null) {
+        const expected = expectedContentAfterStartMarker;
+        const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+        throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+    }
+    const first = current;
+    // Balanced depth counting for nested content markers
+    let depth = 0;
+    while (current !== null) {
+        if (isComment(current)) {
+            if (HydrationMarkup.isContentBindingStartMarker(current.data)) {
+                depth++;
+            }
+            else if (HydrationMarkup.isContentBindingEndMarker(current.data)) {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+        }
+        nodes.push(current);
+        current = walker.nextSibling();
+    }
+    if (current === null) {
+        const expected = expectedContentEndMarker;
+        const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+        throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+    }
+    current.data = "";
+    if (nodes.length === 1 && isText(nodes[0])) {
+        targetFactory(factory, nodes[0], targets);
+    }
+    else {
+        // If current === first, it means there is no content in
+        // the view. This happens when a `when` directive evaluates false,
+        // or whenever a content binding returns null or undefined.
+        if (current !== first && current.previousSibling !== null) {
+            boundaries[factory.targetNodeId] = {
+                first,
+                last: current.previousSibling,
+            };
+        }
+        // Insert a text node so text content binding targets it
+        const dummyTextNode = current.parentNode.insertBefore(document.createTextNode(""), current);
+        targetFactory(factory, dummyTextNode, targets);
+    }
+}
+/**
+ * Skips past a nested custom element's shadow content using balanced
+ * depth counting to handle nested element boundaries correctly.
+ */
+function skipToElementBoundaryEnd(walker, factories, startNode) {
+    let depth = 0;
+    let current = walker.nextSibling();
+    while (current !== null) {
+        if (isComment(current)) {
+            if (HydrationMarkup.isElementBoundaryStartMarker(current)) {
+                current.data = "";
+                depth++;
+            }
+            else if (HydrationMarkup.isElementBoundaryEndMarker(current)) {
+                if (depth === 0) {
+                    current.data = "";
+                    return;
+                }
+                current.data = "";
+                depth--;
+            }
+        }
+        current = walker.nextSibling();
+    }
+    const expected = expectedElementBoundaryEndMarker;
+    const result = getHydrationDiagnostic().formatStructuralError(startNode, getHostName(startNode), expected);
+    throw new HydrationTargetElementError(result.message, factories, startNode, result.expected, result.received);
+}
+/**
+ * Counts how many factories at the start of the array are host bindings (targetNodeId='h').
+ * Host bindings target the custom element itself and are not represented by SSR markers,
+ * so the factory pointer must start past them.
+ */
+function getHydrationIndexOffset(factories) {
+    let offset = 0;
+    for (let i = 0, ii = factories.length; i < ii; ++i) {
+        if (factories[i].targetNodeId === "h") {
+            offset++;
+        }
+        else {
+            break;
+        }
+    }
+    return offset;
+}
+export function targetFactory(factory, node, targets) {
+    if (factory.targetNodeId === undefined) {
+        // Dev error, this shouldn't ever be thrown
+        throw new Error("Factory could not be target to the node");
+    }
+    targets[factory.targetNodeId] = node;
+}

package/dist/esm/index.debug.js

@@ -0,0 +1,3 @@
+import { enableDebug } from "./debug.js";
+enableDebug();
+export * from "./index.js";

package/dist/esm/index.js

@@ -0,0 +1,49 @@
+/**
+ * Core APIs for building standards-based Web Components with FAST Element.
+ * @packageDocumentation
+ */
+// Binding
+export { Binding } from "./binding/binding.js";
+export { normalizeBinding } from "./binding/normalize.js";
+export { oneTime } from "./binding/one-time.js";
+export { listener, oneWay } from "./binding/one-way.js";
+export { Signal, signal } from "./binding/signal.js";
+export { TwoWaySettings, twoWay, } from "./binding/two-way.js";
+// Components
+export { AttributeConfiguration, AttributeDefinition, attr, booleanConverter, nullableBooleanConverter, nullableNumberConverter, } from "./components/attributes.js";
+export { ElementController, Stages, } from "./components/element-controller.js";
+export { FASTElementDefinition } from "./components/fast-definitions.js";
+export { customElement, FASTElement, } from "./components/fast-element.js";
+export { fastElementRegistry, } from "./components/fast-element-registry.js";
+export { enableDebug } from "./debug.js";
+export { DOM, DOMAspect } from "./dom.js";
+export { DOMPolicy, } from "./dom-policy.js";
+export { ArrayObserver, lengthOf, Sort, Splice, SpliceStrategy, SpliceStrategySupport, sortedCount, } from "./observation/arrays.js";
+// Observation
+export { PropertyChangeNotifier, SubscriberSet, } from "./observation/notifier.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, } from "./observation/observable.js";
+export { Updates } from "./observation/update-queue.js";
+export { volatile } from "./observation/volatile.js";
+export { emptyArray, FAST } from "./platform.js";
+export { Schema, schemaRegistry, } from "./schema.js";
+export * from "./state/exports.js";
+// Styles
+export { css } from "./styles/css.js";
+export { CSSDirective, cssDirective, } from "./styles/css-directive.js";
+export { ElementStyles } from "./styles/element-styles.js";
+// Directives
+export { ChildrenDirective, children, } from "./templating/children.js";
+// Templating
+export { Compiler } from "./templating/compiler.js";
+export { HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { HTMLDirective, htmlDirective, StatelessAttachedAttributeDirective, } from "./templating/html-directive.js";
+export { Markup, Parser } from "./templating/markup.js";
+export { elements, NodeObservationDirective, } from "./templating/node-observation.js";
+export { RefDirective, ref } from "./templating/ref.js";
+export { RenderBehavior, RenderDirective, render } from "./templating/render.js";
+export { RepeatBehavior, RepeatDirective, repeat, } from "./templating/repeat.js";
+export { SlottedDirective, slotted, } from "./templating/slotted.js";
+export { html, InlineTemplateDirective, ViewTemplate, } from "./templating/template.js";
+export { DefaultExecutionContext, HTMLView, } from "./templating/view.js";
+export { when } from "./templating/when.js";
+export * from "./utilities.js";

package/dist/esm/index.rollup.debug.js

@@ -0,0 +1,6 @@
+import { enableDebug } from "./debug.js";
+import { DOM } from "./dom.js";
+import { DOMPolicy } from "./dom-policy.js";
+enableDebug();
+export * from "./index.js";
+DOM.setPolicy(DOMPolicy.create());

package/dist/esm/index.rollup.js

@@ -0,0 +1,4 @@
+import { DOM } from "./dom.js";
+import { DOMPolicy } from "./dom-policy.js";
+export * from "./index.js";
+DOM.setPolicy(DOMPolicy.create());

package/dist/esm/interfaces.js

@@ -0,0 +1,55 @@
+/**
+ * Warning and error messages.
+ * @internal
+ */
+export var Message;
+(function (Message) {
+    // 1000 - 1100 Kernel
+    // 1101 - 1200 Observation
+    Message[Message["needsArrayObservation"] = 1101] = "needsArrayObservation";
+    // 1201 - 1300 Templating
+    Message[Message["onlySetDOMPolicyOnce"] = 1201] = "onlySetDOMPolicyOnce";
+    Message[Message["bindingInnerHTMLRequiresTrustedTypes"] = 1202] = "bindingInnerHTMLRequiresTrustedTypes";
+    Message[Message["twoWayBindingRequiresObservables"] = 1203] = "twoWayBindingRequiresObservables";
+    Message[Message["hostBindingWithoutHost"] = 1204] = "hostBindingWithoutHost";
+    Message[Message["unsupportedBindingBehavior"] = 1205] = "unsupportedBindingBehavior";
+    Message[Message["directCallToHTMLTagNotAllowed"] = 1206] = "directCallToHTMLTagNotAllowed";
+    Message[Message["onlySetTemplatePolicyOnce"] = 1207] = "onlySetTemplatePolicyOnce";
+    Message[Message["cannotSetTemplatePolicyAfterCompilation"] = 1208] = "cannotSetTemplatePolicyAfterCompilation";
+    Message[Message["blockedByDOMPolicy"] = 1209] = "blockedByDOMPolicy";
+    Message[Message["invalidHydrationAttributeMarker"] = 1210] = "invalidHydrationAttributeMarker";
+    Message[Message["duplicateRenderInstruction"] = 1211] = "duplicateRenderInstruction";
+    // 1301 - 1400 Styles
+    // 1401 - 1500 Components
+    Message[Message["missingElementDefinition"] = 1401] = "missingElementDefinition";
+    // 1501 - 1600 Context and Dependency Injection
+    Message[Message["noRegistrationForContext"] = 1501] = "noRegistrationForContext";
+    Message[Message["noFactoryForResolver"] = 1502] = "noFactoryForResolver";
+    Message[Message["invalidResolverStrategy"] = 1503] = "invalidResolverStrategy";
+    Message[Message["cannotAutoregisterDependency"] = 1504] = "cannotAutoregisterDependency";
+    Message[Message["cannotResolveKey"] = 1505] = "cannotResolveKey";
+    Message[Message["cannotConstructNativeFunction"] = 1506] = "cannotConstructNativeFunction";
+    Message[Message["cannotJITRegisterNonConstructor"] = 1507] = "cannotJITRegisterNonConstructor";
+    Message[Message["cannotJITRegisterIntrinsic"] = 1508] = "cannotJITRegisterIntrinsic";
+    Message[Message["cannotJITRegisterInterface"] = 1509] = "cannotJITRegisterInterface";
+    Message[Message["invalidResolver"] = 1510] = "invalidResolver";
+    Message[Message["invalidKey"] = 1511] = "invalidKey";
+    Message[Message["noDefaultResolver"] = 1512] = "noDefaultResolver";
+    Message[Message["cyclicDependency"] = 1513] = "cyclicDependency";
+    Message[Message["connectUpdateRequiresController"] = 1514] = "connectUpdateRequiresController";
+})(Message || (Message = {}));
+/**
+ * Determines whether or not an object is a function.
+ * @public
+ */
+export const isFunction = (object) => typeof object === "function";
+/**
+ * Determines whether or not an object is a string.
+ * @public
+ */
+export const isString = (object) => typeof object === "string";
+/**
+ * A function which does nothing.
+ * @public
+ */
+export const noop = () => void 0;

package/dist/esm/metadata.js

@@ -0,0 +1,57 @@
+import { emptyArray } from "./platform.js";
+// Tiny polyfill for TypeScript's Reflect metadata API.
+const metadataByTarget = new Map();
+if (!("metadata" in Reflect)) {
+    Reflect.metadata = function (key, value) {
+        return function (target) {
+            Reflect.defineMetadata(key, value, target);
+        };
+    };
+    Reflect.defineMetadata = function (key, value, target) {
+        let metadata = metadataByTarget.get(target);
+        if (metadata === void 0) {
+            metadataByTarget.set(target, (metadata = new Map()));
+        }
+        metadata.set(key, value);
+    };
+    Reflect.getOwnMetadata = function (key, target) {
+        const metadata = metadataByTarget.get(target);
+        if (metadata !== void 0) {
+            return metadata.get(key);
+        }
+        return void 0;
+    };
+}
+const annotationParamTypesKey = "annotation:paramtypes";
+const designParamTypesKey = "design:paramtypes";
+/**
+ * Provides basic metadata capabilities used by Context and Dependency Injection.
+ * @public
+ */
+export const Metadata = Object.freeze({
+    /**
+     * Gets the "design:paramtypes" metadata for the specified type.
+     * @param Type - The type to get the metadata for.
+     * @returns The metadata array or a frozen empty array if no metadata is found.
+     */
+    getDesignParamTypes: (Type) => { var _a; return ((_a = Reflect.getOwnMetadata(designParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray); },
+    /**
+     * Gets the "annotation:paramtypes" metadata for the specified type.
+     * @param Type - The type to get the metadata for.
+     * @returns The metadata array or a frozen empty array if no metadata is found.
+     */
+    getAnnotationParamTypes: (Type) => { var _a; return ((_a = Reflect.getOwnMetadata(annotationParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray); },
+    /**
+     * Gets the "annotation:paramtypes" metadata for the specified type. If none is found,
+     * an empty, mutable metadata array is created and added.
+     * @param Type - The type to get or create the metadata for.
+     * @returns A mutable metadata array.
+     */
+    getOrCreateAnnotationParamTypes(Type) {
+        let types = this.getAnnotationParamTypes(Type);
+        if (types === emptyArray) {
+            Reflect.defineMetadata(annotationParamTypesKey, (types = []), Type);
+        }
+        return types;
+    },
+});