@ng-prism/core 22.5.0 → 22.7.0-beta.0

package/dist/app/pseudo/pseudo-targets.js

@@ -0,0 +1,46 @@
+import { PSEUDO_STATES } from '../../shared/pseudo-state.type.js';
+/** True when `states` forces at least one state on at least one target. */
+export function forcesAnyState(states) {
+    return !!states && PSEUDO_STATES.some((state) => hasTarget(states[state]));
+}
+/** True when `target` names something: `true`, or a selector that is not blank. */
+export function hasTarget(target) {
+    if (target === true)
+        return true;
+    if (typeof target === 'string')
+        return target.trim() !== '';
+    return Array.isArray(target) && target.some((selector) => typeof selector === 'string' && selector.trim() !== '');
+}
+const warnedSelectors = new Set();
+/**
+ * The elements under `root` a target names. `root` counts: a selector can name
+ * the component's host, and `true` includes it.
+ */
+export function resolveTargets(root, target) {
+    const targets = new Set();
+    if (target === undefined)
+        return targets;
+    if (target === true) {
+        targets.add(root);
+        for (const el of Array.from(root.querySelectorAll('*')))
+            targets.add(el);
+        return targets;
+    }
+    for (const selector of typeof target === 'string' ? [target] : target) {
+        if (typeof selector !== 'string' || selector.trim() === '')
+            continue;
+        try {
+            if (root.matches(selector))
+                targets.add(root);
+            for (const el of Array.from(root.querySelectorAll(selector)))
+                targets.add(el);
+        }
+        catch {
+            if (!warnedSelectors.has(selector)) {
+                warnedSelectors.add(selector);
+                console.warn(`[ng-prism] "${selector}" in forced pseudo states is not a valid selector, skipping it.`);
+            }
+        }
+    }
+    return targets;
+}

package/dist/app/pseudo/state-fit.d.ts

@@ -0,0 +1,28 @@
+import { type ForcedPseudoStates, type PseudoState, type PseudoTarget } from '../../shared/pseudo-state.type.js';
+/** Whether a state can be forced on a rendered component, and if not, why. */
+export type StateFit = {
+    fits: true;
+} | {
+    fits: false;
+    reason: string;
+};
+/** `true` is the whole component, a selector list reads as its selectors joined with `, `. */
+export declare function describeTarget(target: PseudoTarget): string;
+/**
+ * The subset of `elements` the browser could put into `state`: what a user
+ * could focus, or hover, or press. Forcing a state on anything else would show
+ * something the component can never be in.
+ *
+ * `focus-within` is not filtered. Whether some descendant takes focus cannot be
+ * told without a browser API for focusability.
+ */
+export declare function reachableTargets(root: Element, state: PseudoState, elements: Iterable<Element>): Element[];
+/**
+ * Fits when every pseudo-class of `pseudo` has at least one reachable target
+ * under `root`. The reason names the first pseudo-class, in
+ * {@link PSEUDO_STATES} order, that does not. Focus on the whole component is
+ * decided on what could take focus ({@link fitCandidates}); which elements get
+ * the class is not affected.
+ */
+export declare function evaluateStateFit(root: Element, pseudo: ForcedPseudoStates): StateFit;
+//# sourceMappingURL=state-fit.d.ts.map

package/dist/app/pseudo/state-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-fit.d.ts","sourceRoot":"","sources":["../../../src/app/pseudo/state-fit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAiB,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAGhI,8EAA8E;AAC9E,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,8FAA8F;AAC9F,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAG3D;AA4BD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,EAAE,CAc1G;AAyBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,kBAAkB,GAAG,QAAQ,CAkBpF"}

package/dist/app/pseudo/state-fit.js

@@ -0,0 +1,97 @@
+import { PSEUDO_STATES } from '../../shared/pseudo-state.type.js';
+import { forcesAnyState, resolveTargets } from './pseudo-targets.js';
+/** `true` is the whole component, a selector list reads as its selectors joined with `, `. */
+export function describeTarget(target) {
+    if (target === true)
+        return 'the component';
+    return typeof target === 'string' ? target : target.join(', ');
+}
+function isDisabled(el) {
+    return el.matches(':disabled');
+}
+/** Under `[inert]` within the component: an `inert` outside `root` is not the component's doing. */
+function isInert(root, el) {
+    const inert = el.closest('[inert]');
+    return inert !== null && root.contains(inert);
+}
+/**
+ * Whether `el` or something inside it receives the pointer. `pointer-events`
+ * inherits, so a subtree of `none` is unreachable unless a descendant sets it
+ * back, and then the browser hands that descendant the hover.
+ */
+function takesPointer(el, known) {
+    let reachable = known.get(el);
+    if (reachable === undefined) {
+        reachable = getComputedStyle(el).pointerEvents !== 'none' || Array.from(el.children).some((child) => takesPointer(child, known));
+        known.set(el, reachable);
+    }
+    return reachable;
+}
+/**
+ * The subset of `elements` the browser could put into `state`: what a user
+ * could focus, or hover, or press. Forcing a state on anything else would show
+ * something the component can never be in.
+ *
+ * `focus-within` is not filtered. Whether some descendant takes focus cannot be
+ * told without a browser API for focusability.
+ */
+export function reachableTargets(root, state, elements) {
+    switch (state) {
+        case 'focus':
+        case 'focus-visible':
+            return Array.from(elements).filter((el) => !isDisabled(el) && !isInert(root, el));
+        case 'hover':
+        case 'active': {
+            const known = new Map();
+            return Array.from(elements).filter((el) => takesPointer(el, known));
+        }
+        case 'focus-within':
+            return Array.from(elements);
+    }
+}
+/** What can take focus at all, whether or not it is disabled or inert now. */
+const FOCUSABLE = 'button, input, select, textarea, a[href], area[href], summary, iframe, [tabindex], [contenteditable]:not([contenteditable="false"])';
+/**
+ * The targets the fit of `state` is decided on. For focus on the whole
+ * component (`true`) that is what could take focus at all: the host is never
+ * `:disabled`, so a component whose only focusable element is disabled would
+ * otherwise fit, and show the plain default under a focus label. A component
+ * with nothing focusable in it keeps every element, as before.
+ */
+function fitCandidates(state, target, targets) {
+    if (target !== true || (state !== 'focus' && state !== 'focus-visible'))
+        return targets;
+    const focusable = Array.from(targets).filter((el) => el.matches(FOCUSABLE));
+    return focusable.length > 0 ? new Set(focusable) : targets;
+}
+/** Why `elements`, all of them unreachable for `state`, are: the first applicable of disabled, inert and pointer-events. */
+function unreachableReason(state, elements) {
+    if (state === 'hover' || state === 'active')
+        return 'has pointer-events: none';
+    return Array.from(elements).some(isDisabled) ? 'is disabled' : 'is inert';
+}
+/**
+ * Fits when every pseudo-class of `pseudo` has at least one reachable target
+ * under `root`. The reason names the first pseudo-class, in
+ * {@link PSEUDO_STATES} order, that does not. Focus on the whole component is
+ * decided on what could take focus ({@link fitCandidates}); which elements get
+ * the class is not affected.
+ */
+export function evaluateStateFit(root, pseudo) {
+    if (!forcesAnyState(pseudo))
+        return { fits: false, reason: 'forces no state' };
+    for (const state of PSEUDO_STATES) {
+        const target = pseudo[state];
+        // Like the marker, which gives an empty selector no element to mark.
+        if (target === undefined || !forcesAnyState({ [state]: target }))
+            continue;
+        const targets = resolveTargets(root, target);
+        const label = describeTarget(target);
+        if (targets.size === 0)
+            return { fits: false, reason: `${label} matches nothing` };
+        const candidates = fitCandidates(state, target, targets);
+        if (reachableTargets(root, state, candidates).length === 0)
+            return { fits: false, reason: `${label} ${unreachableReason(state, candidates)}` };
+    }
+    return { fits: true };
+}

package/dist/app/renderer/composition.d.ts

@@ -0,0 +1,20 @@
+import type { Type } from '@angular/core';
+import type { CompositionCase, RuntimeComponent } from '../../plugin/plugin.types.js';
+/**
+ * The composition variant `variantIndex` renders in, `null` for a variant without one, which renders the class (or the
+ * `__PrismHost` of a directive) as before. Also `null` when the manifest has no wrapper to render the case in.
+ */
+export declare function activeCase(comp: RuntimeComponent, variantIndex: number): CompositionCase | null;
+/** The class to create for variant `variantIndex`: the composition wrapper for a composed variant, else `comp.type`. */
+export declare function renderTypeFor(comp: RuntimeComponent, variantIndex: number): Type<unknown>;
+/** What a render consists of: when two are the same, a variant switch sets the inputs on the instance instead of creating a new one. */
+export interface RenderSignature {
+    type: Type<unknown>;
+    /** `variantIndex` only for a composed variant: two composed variants are two renders even with equal inputs. */
+    variantIndex: number | null;
+    content: string | Record<string, string> | undefined;
+}
+export declare function renderSignature(comp: RuntimeComponent, variantIndex: number, content: RenderSignature['content']): RenderSignature;
+/** Whether `b` renders what `a` rendered, `a` being `null` while nothing is rendered. Content compares by identity. */
+export declare function sameRender(a: RenderSignature | null, b: RenderSignature): boolean;
+//# sourceMappingURL=composition.d.ts.map

package/dist/app/renderer/composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../../../src/app/renderer/composition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAEtF;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAO/F;AAED,wHAAwH;AACxH,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAEzF;AAED,wIAAwI;AACxI,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACpB,gHAAgH;IAChH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CACxD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,GAAG,eAAe,CAMlI;AAED,uHAAuH;AACvH,wBAAgB,UAAU,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,EAAE,CAAC,EAAE,eAAe,GAAG,OAAO,CAEjF"}

package/dist/app/renderer/composition.js

@@ -0,0 +1,26 @@
+/**
+ * The composition variant `variantIndex` renders in, `null` for a variant without one, which renders the class (or the
+ * `__PrismHost` of a directive) as before. Also `null` when the manifest has no wrapper to render the case in.
+ */
+export function activeCase(comp, variantIndex) {
+    const composition = comp.meta.composition;
+    if (!composition || !comp.composition)
+        return null;
+    const caseIndex = composition.variantCases[variantIndex] ?? -1;
+    return caseIndex < 0 ? null : (composition.cases[caseIndex] ?? null);
+}
+/** The class to create for variant `variantIndex`: the composition wrapper for a composed variant, else `comp.type`. */
+export function renderTypeFor(comp, variantIndex) {
+    return activeCase(comp, variantIndex) && comp.composition ? comp.composition : comp.type;
+}
+export function renderSignature(comp, variantIndex, content) {
+    return {
+        type: renderTypeFor(comp, variantIndex),
+        variantIndex: activeCase(comp, variantIndex) ? variantIndex : null,
+        content
+    };
+}
+/** Whether `b` renders what `a` rendered, `a` being `null` while nothing is rendered. Content compares by identity. */
+export function sameRender(a, b) {
+    return a !== null && a.type === b.type && a.variantIndex === b.variantIndex && a.content === b.content;
+}

package/dist/app/renderer/input-bindings.d.ts

@@ -0,0 +1,28 @@
+import type { RuntimeComponent } from '../../plugin/plugin.types.js';
+/** Synthetic input the manifest generator emits on directive wrapper classes
+ * to project per-variant `content` text into the host element. The directive
+ * itself doesn't declare it, so it isn't in `meta.inputs`, and code that
+ * validates / filters inputs against that list must allow this key through.
+ */
+export declare const PRISM_CONTENT_INPUT = "__prismContent__";
+/**
+ * The inputs a variant may set, by class member name, each mapped to the name
+ * `ComponentRef.setInput` takes. Angular resolves that by the public name, so a
+ * component's aliased input maps to its alias. A directive renders inside the
+ * generated `__PrismHost` wrapper, which declares the inputs under their member
+ * names and binds the aliases itself.
+ *
+ * With `variantIndex`, a composed variant renders in the composition wrapper,
+ * which declares the inputs under their member names as well, and only those
+ * its case binds.
+ */
+export declare function buildInputBindings(comp: RuntimeComponent, variantIndex?: number): Map<string, string>;
+/**
+ * What a composed variant leaves out of {@link buildInputBindings} on purpose:
+ * the inputs its case does not bind, and `__prismContent__`, which only the
+ * `__PrismHost` of a directive declares. A value for one of them is skipped
+ * without the warning about an unknown input. Empty for a variant without a
+ * composition.
+ */
+export declare function unboundInputs(comp: RuntimeComponent, variantIndex: number): ReadonlySet<string>;
+//# sourceMappingURL=input-bindings.d.ts.map

package/dist/app/renderer/input-bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-bindings.d.ts","sourceRoot":"","sources":["../../../src/app/renderer/input-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGrE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAgBrG;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAI/F"}

package/dist/app/renderer/input-bindings.js

@@ -0,0 +1,42 @@
+import { activeCase } from './composition.js';
+/** Synthetic input the manifest generator emits on directive wrapper classes
+ * to project per-variant `content` text into the host element. The directive
+ * itself doesn't declare it, so it isn't in `meta.inputs`, and code that
+ * validates / filters inputs against that list must allow this key through.
+ */
+export const PRISM_CONTENT_INPUT = '__prismContent__';
+/**
+ * The inputs a variant may set, by class member name, each mapped to the name
+ * `ComponentRef.setInput` takes. Angular resolves that by the public name, so a
+ * component's aliased input maps to its alias. A directive renders inside the
+ * generated `__PrismHost` wrapper, which declares the inputs under their member
+ * names and binds the aliases itself.
+ *
+ * With `variantIndex`, a composed variant renders in the composition wrapper,
+ * which declares the inputs under their member names as well, and only those
+ * its case binds.
+ */
+export function buildInputBindings(comp, variantIndex) {
+    const composition = variantIndex === undefined ? null : activeCase(comp, variantIndex);
+    if (composition) {
+        const unbound = new Set(composition.unbound.map(({ name }) => name));
+        return new Map(comp.meta.inputs.filter(({ name }) => !unbound.has(name)).map(({ name }) => [name, name]));
+    }
+    const isDirective = comp.meta.componentMeta.isDirective;
+    const bindings = new Map(comp.meta.inputs.map((i) => [i.name, isDirective ? i.name : (i.alias ?? i.name)]));
+    if (isDirective) {
+        bindings.set(PRISM_CONTENT_INPUT, PRISM_CONTENT_INPUT);
+    }
+    return bindings;
+}
+/**
+ * What a composed variant leaves out of {@link buildInputBindings} on purpose:
+ * the inputs its case does not bind, and `__prismContent__`, which only the
+ * `__PrismHost` of a directive declares. A value for one of them is skipped
+ * without the warning about an unknown input. Empty for a variant without a
+ * composition.
+ */
+export function unboundInputs(comp, variantIndex) {
+    const composition = activeCase(comp, variantIndex);
+    return new Set(composition ? [...composition.unbound.map(({ name }) => name), PRISM_CONTENT_INPUT] : []);
+}

package/dist/app/renderer/known-inputs.d.ts

@@ -5,5 +5,12 @@ import type { RuntimeComponent } from '../../plugin/plugin.types.js';
  * validates / filters inputs against that list must allow this key through.
  */
 export declare const PRISM_CONTENT_INPUT = "__prismContent__";
-export declare function buildKnownInputs(comp: RuntimeComponent): Set<string>;
+/**
+ * The inputs a variant may set, by class member name, each mapped to the name
+ * `ComponentRef.setInput` takes. Angular resolves that by the public name, so a
+ * component's aliased input maps to its alias. A directive renders inside the
+ * generated `__PrismHost` wrapper, which declares the inputs under their member
+ * names and binds the aliases itself.
+ */
+export declare function buildInputBindings(comp: RuntimeComponent): Map<string, string>;
 //# sourceMappingURL=known-inputs.d.ts.map

package/dist/app/renderer/known-inputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"known-inputs.d.ts","sourceRoot":"","sources":["../../../src/app/renderer/known-inputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AAEtD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,gBAAgB,GAAG,GAAG,CAAC,MAAM,CAAC,CAOpE"}
+{"version":3,"file":"known-inputs.d.ts","sourceRoot":"","sources":["../../../src/app/renderer/known-inputs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AAEtD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ9E"}

package/dist/app/renderer/known-inputs.js

@@ -4,10 +4,18 @@
  * validates / filters inputs against that list must allow this key through.
  */
 export const PRISM_CONTENT_INPUT = '__prismContent__';
-export function buildKnownInputs(comp) {
-    const known = new Set(comp.meta.inputs.map((i) => i.name));
-    if (comp.meta.componentMeta.isDirective) {
-        known.add(PRISM_CONTENT_INPUT);
+/**
+ * The inputs a variant may set, by class member name, each mapped to the name
+ * `ComponentRef.setInput` takes. Angular resolves that by the public name, so a
+ * component's aliased input maps to its alias. A directive renders inside the
+ * generated `__PrismHost` wrapper, which declares the inputs under their member
+ * names and binds the aliases itself.
+ */
+export function buildInputBindings(comp) {
+    const isDirective = comp.meta.componentMeta.isDirective;
+    const bindings = new Map(comp.meta.inputs.map((i) => [i.name, isDirective ? i.name : (i.alias ?? i.name)]));
+    if (isDirective) {
+        bindings.set(PRISM_CONTENT_INPUT, PRISM_CONTENT_INPUT);
     }
-    return known;
+    return bindings;
 }

package/dist/app/renderer/prism-renderer.component.d.ts

@@ -49,18 +49,26 @@ export declare class PrismRendererComponent {
     private readonly outlet;
     private componentRef;
     private outputSubscriptions;
-    private lastProjectedContent;
+    /** What the instance on the canvas renders, `null` without one: a variant switch to another render creates a new instance. */
+    private lastRender;
     private isRenderPage;
     private readonly overlayCache;
     readonly activeOverlay: import("@angular/core").WritableSignal<Type<unknown> | null>;
     /**
-     * Identifier of the currently rendered component/variant (for audit tooling / e2e).
-     * Held back until the variant's forced pseudo states are in place, see {@link resolveRenderedKey}.
+     * Identifier of the currently rendered component/variant, and of the active state.
+     * Held back until the forced pseudo states and the state are in place, see {@link resolveRenderedKey}.
      */
     protected readonly renderedKey: import("@angular/core").Signal<string | null>;
+    /**
+     * Why the active state is not part of what the canvas shows, `null` when it is
+     * or none is active. A runner reads it next to `data-prism-rendered` and
+     * reports the cell as excluded rather than taking a picture of it.
+     */
+    protected readonly excludedReason: import("@angular/core").Signal<string | null>;
     /**
      * The states forced on the canvas, space-separated, `null` for none. Capture
-     * mode keys the room it leaves for focus rings on it.
+     * mode keys the room it leaves for focus rings on it. The active state's
+     * pseudo-classes count only while it fits.
      */
     protected readonly forcedStates: import("@angular/core").Signal<string | null>;
     /** Resolved canvas layout for the active variant. Variant overrides component config; defaults to 'fit'. */
@@ -71,6 +79,12 @@ export declare class PrismRendererComponent {
     protected readonly overlayInjector: import("@angular/core").Signal<import("@angular/core").EnvironmentInjector | Injector>;
     constructor();
     private createComponent;
+    /**
+     * Sets `values` on the instance by the bindings of the variant. A key that
+     * names no input gets a warning, an input the composition of the variant
+     * leaves unbound is skipped without one.
+     */
+    private setInputs;
     private cleanup;
     static ɵfac: i0.ɵɵFactoryDeclaration<PrismRendererComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PrismRendererComponent, "prism-renderer", never, {}, {}, never, never, true, never>;

package/dist/app/renderer/prism-renderer.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prism-renderer.component.d.ts","sourceRoot":"","sources":["../../../src/app/renderer/prism-renderer.component.ts"],"names":[],"mappings":"AACA,OAAO,EASH,QAAQ,EAER,KAAK,IAAI,EAIZ,MAAM,eAAe,CAAC;AAYvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAG3E,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAIjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;;AAOhF,qBASa,sBAAsB;IAC/B,SAAS,CAAC,QAAQ,CAAC,iBAAiB,yBAAkC;IACtE,SAAS,CAAC,QAAQ,CAAC,eAAe,uBAAgC;IAClE,SAAS,CAAC,QAAQ,CAAC,aAAa,qBAA8B;IAC9D,SAAS,CAAC,QAAQ,CAAC,OAAO,sBAA+B;IACzD,SAAS,CAAC,QAAQ,CAAC,SAAS,wBAAiC;IAC7D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmC;IAE/D;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,gDAAuF;IAEvH,SAAS,CAAC,QAAQ,CAAC,YAAY,OAAgB;IAC/C,SAAS,CAAC,QAAQ,CAAC,YAAY,QAAgB;IAE/C;;;;;;;OAOG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI/C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgC;IAChE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgC;IAChE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmC;IACxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAE3B;IAEH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA8B;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAEhE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAEpB;IACH,OAAO,CAAC,YAAY,CAAsC;IAC1D,OAAO,CAAC,mBAAmB,CAAsC;IACjE,OAAO,CAAC,oBAAoB,CAA0D;IACtF,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoC;IACjE,QAAQ,CAAC,aAAa,+DAAsC;IAC5D;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,WAAW,gDAQ5B;IACF;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,gDAI5B;IACH,4GAA4G;IAC5G,SAAS,CAAC,QAAQ,CAAC,YAAY,4FAO5B;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa;;MAA6C;IAC7E,SAAS,CAAC,QAAQ,CAAC,eAAe,yFAI/B;;IA2FH,OAAO,CAAC,eAAe;IA8EvB,OAAO,CAAC,OAAO;yCA1QN,sBAAsB;2CAAtB,sBAAsB;CAyRlC"}
+{"version":3,"file":"prism-renderer.component.d.ts","sourceRoot":"","sources":["../../../src/app/renderer/prism-renderer.component.ts"],"names":[],"mappings":"AACA,OAAO,EASH,QAAQ,EAGR,KAAK,IAAI,EAIZ,MAAM,eAAe,CAAC;AAavB,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAG3E,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAIjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;;AAQhF,qBASa,sBAAsB;IAC/B,SAAS,CAAC,QAAQ,CAAC,iBAAiB,yBAAkC;IACtE,SAAS,CAAC,QAAQ,CAAC,eAAe,uBAAgC;IAClE,SAAS,CAAC,QAAQ,CAAC,aAAa,qBAA8B;IAC9D,SAAS,CAAC,QAAQ,CAAC,OAAO,sBAA+B;IACzD,SAAS,CAAC,QAAQ,CAAC,SAAS,wBAAiC;IAC7D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmC;IAE/D;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa,gDAAuF;IAEvH,SAAS,CAAC,QAAQ,CAAC,YAAY,OAAgB;IAC/C,SAAS,CAAC,QAAQ,CAAC,YAAY,QAAgB;IAE/C;;;;;;;OAOG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI/C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgC;IAChE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAgC;IAChE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmC;IACxD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAE3B;IAEH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA8B;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAEhE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAEpB;IACH,OAAO,CAAC,YAAY,CAAsC;IAC1D,OAAO,CAAC,mBAAmB,CAAsC;IACjE,8HAA8H;IAC9H,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoC;IACjE,QAAQ,CAAC,aAAa,+DAAsC;IAC5D;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,WAAW,gDAY3B;IACH;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,gDAE/B;IACF;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,gDAI5B;IACH,4GAA4G;IAC5G,SAAS,CAAC,QAAQ,CAAC,YAAY,4FAO5B;IACH,SAAS,CAAC,QAAQ,CAAC,aAAa;;MAA6C;IAC7E,SAAS,CAAC,QAAQ,CAAC,eAAe,yFAI/B;;IA0FH,OAAO,CAAC,eAAe;IAgFvB;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,OAAO;yCA7SN,sBAAsB;2CAAtB,sBAAsB;CA4TlC"}