rete-angular-plugin 0.0.0 → 2.0.0

package/14/presets/minimap/components/mini-viewport/mini-viewport.component.d.ts

@@ -0,0 +1,27 @@
+import { MinimapData } from '../../types';
+import * as i0 from "@angular/core";
+export declare class MiniViewportComponent {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    containerWidth: number;
+    translate: MinimapData['translate'];
+    drag: {
+        start(e: {
+            pageX: number;
+            pageY: number;
+        }): void;
+    };
+    get styleLeft(): string;
+    get styleTop(): string;
+    get styleWidth(): string;
+    get styleHeight(): string;
+    pointerdown(event: PointerEvent): void;
+    px(value: number): string;
+    scale(v: number): number;
+    invert(v: number): number;
+    onDrag(dx: number, dy: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniViewportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MiniViewportComponent, "minimap-mini-viewport", never, { "left": "left"; "top": "top"; "width": "width"; "height": "height"; "containerWidth": "containerWidth"; "translate": "translate"; }, {}, never, never, false>;
+}

package/14/presets/minimap/components/minimap/minimap.component.d.ts

@@ -0,0 +1,25 @@
+import { ChangeDetectorRef, OnChanges, ElementRef } from '@angular/core';
+import { MinimapData } from '../../types';
+import * as i0 from "@angular/core";
+export declare class MinimapComponent implements OnChanges {
+    el: ElementRef;
+    private cdr;
+    rendered: () => void;
+    size: number;
+    ratio: MinimapData['ratio'];
+    nodes: MinimapData['nodes'];
+    viewport: MinimapData['viewport'];
+    translate: MinimapData['translate'];
+    point: MinimapData['point'];
+    get width(): string;
+    get height(): string;
+    pointerdown(event: PointerEvent): void;
+    dblclick(event: MouseEvent): void;
+    constructor(el: ElementRef, cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    px(value: number): string;
+    scale(value: number): number;
+    identifyMiniNode(_: number, item: MinimapData['nodes'][number]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MinimapComponent, "ng-component", never, { "rendered": "rendered"; "size": "size"; "ratio": "ratio"; "nodes": "nodes"; "viewport": "viewport"; "translate": "translate"; "point": "point"; }, {}, never, never, false>;
+}

package/14/presets/minimap/index.d.ts

@@ -0,0 +1,6 @@
+import { BaseSchemes } from 'rete';
+import { RenderPreset } from '../types';
+import { MinimapRender } from './types';
+export declare function setup<Schemes extends BaseSchemes, K extends MinimapRender>(props?: {
+    size?: number;
+}): RenderPreset<Schemes, K>;

package/14/presets/minimap/module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/minimap/minimap.component";
+import * as i2 from "./components/mini-viewport/mini-viewport.component";
+import * as i3 from "./components/mini-node/mini-node.component";
+import * as i4 from "@angular/common";
+export declare class ReteMinimapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReteMinimapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteMinimapModule, [typeof i1.MinimapComponent, typeof i2.MiniViewportComponent, typeof i3.MiniNodeComponent], [typeof i4.CommonModule], [typeof i1.MinimapComponent, typeof i2.MiniViewportComponent, typeof i3.MiniNodeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReteMinimapModule>;
+}

package/14/presets/minimap/types.d.ts

@@ -0,0 +1,22 @@
+import { RenderSignal } from '../../types';
+export declare type Rect = {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+};
+export declare type Transform = {
+    x: number;
+    y: number;
+    k: number;
+};
+export declare type Translate = (dx: number, dy: number) => void;
+export declare type MinimapData = {
+    ratio: number;
+    nodes: Rect[];
+    viewport: Rect;
+    start(): Transform;
+    translate: Translate;
+    point(x: number, y: number): void;
+};
+export declare type MinimapRender = RenderSignal<'minimap', MinimapData>;

package/14/presets/reroute/components/index.d.ts

@@ -0,0 +1,2 @@
+export { PinsComponent } from './pins/pins.component';
+export { PinComponent } from './pin/pin.component';

package/14/presets/reroute/components/pin/pin.component.d.ts

@@ -0,0 +1,30 @@
+import { ChangeDetectorRef, OnChanges, EventEmitter } from '@angular/core';
+import { Position } from '../../types';
+import * as i0 from "@angular/core";
+export declare class PinComponent implements OnChanges {
+    private cdr;
+    position: Position;
+    selected?: boolean;
+    getPointer: () => Position;
+    menu: EventEmitter<void>;
+    translate: EventEmitter<{
+        dx: number;
+        dy: number;
+    }>;
+    down: EventEmitter<void>;
+    drag: {
+        start(e: {
+            pageX: number;
+            pageY: number;
+        }): void;
+    };
+    get _selected(): boolean;
+    get top(): string;
+    get left(): string;
+    pointerdown(event: PointerEvent): void;
+    contextmenu(event: MouseEvent): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinComponent, "reroute-pin", never, { "position": "position"; "selected": "selected"; "getPointer": "getPointer"; }, { "menu": "menu"; "translate": "translate"; "down": "down"; }, never, never, false>;
+}

package/14/presets/reroute/components/pins/pins.component.d.ts

@@ -0,0 +1,17 @@
+import { ChangeDetectorRef, OnChanges } from '@angular/core';
+import { Pin, PinData, Position } from '../../types';
+import * as i0 from "@angular/core";
+export declare class PinsComponent implements OnChanges {
+    private cdr;
+    rendered: () => void;
+    pins: PinData['pins'];
+    down?: (id: string) => void;
+    translate?: (id: string, dx: number, dy: number) => void;
+    menu?: (id: string) => void;
+    getPointer?: () => Position;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    track(_: number, item: Pin): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinsComponent, "ng-component", never, { "rendered": "rendered"; "pins": "pins"; "down": "down"; "translate": "translate"; "menu": "menu"; "getPointer": "getPointer"; }, {}, never, never, false>;
+}

package/14/presets/reroute/index.d.ts

@@ -0,0 +1,10 @@
+import { BaseSchemes } from 'rete';
+import { RenderPreset } from '../types';
+import { PinsRender } from './types';
+declare type Props = {
+    translate?: (id: string, dx: number, dy: number) => void;
+    contextMenu?: (id: string) => void;
+    pointerdown?: (id: string) => void;
+};
+export declare function setup<Schemes extends BaseSchemes, K extends PinsRender>(props?: Props): RenderPreset<Schemes, K>;
+export {};

package/14/presets/reroute/module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/pins/pins.component";
+import * as i2 from "./components/pin/pin.component";
+import * as i3 from "@angular/common";
+export declare class ReteRerouteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReteRerouteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteRerouteModule, [typeof i1.PinsComponent, typeof i2.PinComponent], [typeof i3.CommonModule], [typeof i1.PinsComponent, typeof i2.PinComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReteRerouteModule>;
+}

package/14/presets/reroute/types.d.ts

@@ -0,0 +1,18 @@
+import { ConnectionId } from 'rete';
+import { RenderSignal } from '../../types';
+export declare type Position = {
+    x: number;
+    y: number;
+};
+export declare type Pin = {
+    id: string;
+    position: Position;
+    selected?: boolean;
+};
+export declare type PinData = {
+    id: ConnectionId;
+    pins: Pin[];
+};
+export declare type PinsRender = RenderSignal<'reroute-pins', {
+    data: PinData;
+}>;

package/14/presets/types.d.ts

@@ -0,0 +1,15 @@
+import { BaseSchemes } from 'rete';
+import { AngularPlugin } from '../core';
+export declare type RenderPreset<Schemes extends BaseSchemes, T> = {
+    attach?: (plugin: AngularPlugin<Schemes, T>) => void;
+    update: (context: Extract<T, {
+        type: 'render';
+    }>, plugin: AngularPlugin<Schemes, T>) => Record<string, unknown> | undefined | null | void;
+    mount: (context: Extract<T, {
+        type: 'render';
+    }>, plugin: AngularPlugin<Schemes, T>) => {
+        key: string;
+        component: any;
+        props: Record<string, unknown>;
+    } | undefined | null | void;
+};

package/14/shared/drag.d.ts

@@ -0,0 +1,10 @@
+import { Position } from '../types';
+declare type Translate = (dx: number, dy: number) => void;
+declare type StartEvent = {
+    pageX: number;
+    pageY: number;
+};
+export declare function useDrag(translate: Translate, getPointer: (e: StartEvent) => Position): {
+    start(e: StartEvent): void;
+};
+export {};

package/14/types.d.ts

@@ -0,0 +1,29 @@
+import { NgElement as NgEl, NgElementStrategy } from '@angular/elements';
+export declare type NgElement = NgEl & {
+    ngElementStrategy: NgElementStrategy & {
+        setInputValue(key: string, value: any): void;
+    };
+};
+export declare type NodeProps = {
+    data: any;
+    rendered: any;
+    emit: any;
+} & NgElement;
+export declare type Position = {
+    x: number;
+    y: number;
+};
+export declare type RenderSignal<Type extends string, Data> = {
+    type: 'render';
+    data: {
+        element: HTMLElement;
+        filled?: boolean;
+        type: Type;
+    } & Data;
+} | {
+    type: 'rendered';
+    data: {
+        element: HTMLElement;
+        type: Type;
+    } & Data;
+};

package/15/core.d.ts

@@ -0,0 +1,48 @@
+import { Injector } from '@angular/core';
+import { BaseSchemes, CanAssignSignal, Scope } from 'rete';
+import { NgElement, Position, RenderSignal } from './types';
+import { RenderPreset } from './presets/types';
+declare type Item = {
+    key: string;
+    ngElement: NgElement;
+};
+declare type Renderer = {
+    get(element: HTMLElement): Item | undefined;
+    mount(element: HTMLElement, key: string, component: any, injector: Injector, props: Record<string, unknown>): void;
+    update(item: Item, props: Record<string, unknown>): void;
+    unmount(element: HTMLElement): void;
+};
+declare type Produces<Schemes extends BaseSchemes> = {
+    type: 'connectionpath';
+    data: {
+        payload: Schemes['Connection'];
+        path?: string;
+        points: Position[];
+    };
+};
+declare type Requires<Schemes extends BaseSchemes> = RenderSignal<'node', {
+    payload: Schemes['Node'];
+}> | RenderSignal<'connection', {
+    payload: Schemes['Connection'];
+    start?: Position;
+    end?: Position;
+}> | {
+    type: 'unmount';
+    data: {
+        element: HTMLElement;
+    };
+};
+export declare class AngularPlugin<Schemes extends BaseSchemes, T = Requires<Schemes>> extends Scope<Produces<Schemes>, [Requires<Schemes> | T]> {
+    private params;
+    presets: RenderPreset<Schemes, T>[];
+    renderer: Renderer;
+    owners: WeakMap<HTMLElement, RenderPreset<Schemes, T>>;
+    constructor(params: {
+        injector: Injector;
+    });
+    setParent(scope: Scope<Requires<Schemes> | T>): void;
+    private unmount;
+    private mount;
+    addPreset<K>(preset: RenderPreset<Schemes, CanAssignSignal<T, K> extends true ? K : 'Cannot apply preset. Provided signals are not compatible'>): void;
+}
+export {};

package/15/esm2020/core.mjs

@@ -0,0 +1,109 @@
+import { Scope } from 'rete';
+import { createCustomElement } from '@angular/elements';
+function getRenderer() {
+    const elements = new WeakMap();
+    return {
+        get(element) {
+            return elements.get(element);
+        },
+        mount(element, key, component, injector, props) {
+            // LIMITATION: If an element is remounted with the same identifier, the component cannot be replaced
+            const exists = customElements.get(key);
+            if (!exists) {
+                customElements.define(key, createCustomElement(component, { injector }));
+            }
+            const ngElement = document.createElement(key);
+            Object.keys(props).forEach(key => {
+                ngElement[key] = props[key];
+            });
+            element.appendChild(ngElement);
+            elements.set(element, { key, ngElement });
+        },
+        update({ ngElement }, props) {
+            Object.keys(props).forEach(key => {
+                ngElement.ngElementStrategy.setInputValue(key, props[key]);
+            });
+            ngElement.ngElementStrategy.setInputValue('seed', Math.random());
+        },
+        unmount(element) {
+            const existing = elements.get(element);
+            if (existing) {
+                existing.ngElement.remove();
+                elements.delete(element);
+            }
+        }
+    };
+}
+export class AngularPlugin extends Scope {
+    constructor(params) {
+        super('angular-render');
+        this.params = params;
+        this.presets = [];
+        this.owners = new WeakMap();
+        this.renderer = getRenderer();
+        this.addPipe(context => {
+            if (!context || typeof context !== 'object' || !('type' in context))
+                return context;
+            if (context.type === 'unmount') {
+                this.unmount(context.data.element);
+            }
+            else if (context.type === 'render') {
+                if ('filled' in context.data && context.data.filled) {
+                    return context;
+                }
+                if (this.mount(context.data.element, context)) {
+                    return {
+                        ...context,
+                        data: {
+                            ...context.data,
+                            filled: true
+                        }
+                    };
+                }
+            }
+            return context;
+        });
+    }
+    setParent(scope) {
+        super.setParent(scope);
+        this.presets.forEach(preset => {
+            if (preset.attach)
+                preset.attach(this);
+        });
+    }
+    unmount(element) {
+        this.owners.delete(element);
+        this.renderer.unmount(element);
+    }
+    mount(element, context) {
+        const existing = this.renderer.get(element);
+        if (existing) {
+            this.presets.forEach(preset => {
+                if (this.owners.get(element) !== preset)
+                    return;
+                const result = preset.update(context, this);
+                if (result) {
+                    this.renderer.update(existing, result);
+                }
+            });
+            return true;
+        }
+        for (const preset of this.presets) {
+            const result = preset.mount(context, this);
+            if (!result)
+                continue;
+            const { key, component, props } = result;
+            this.renderer.mount(element, key, component, this.params.injector, props);
+            this.owners.set(element, preset);
+            return true;
+        }
+        return;
+    }
+    addPreset(preset) {
+        const local = preset;
+        if (local.attach)
+            local.attach(this);
+        this.presets.push(local);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../ng15/src/core.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector } from '@angular/core';\nimport { BaseSchemes, CanAssignSignal, Scope } from 'rete'\nimport { createCustomElement } from '@angular/elements';\n\nimport { NgElement, NodeProps, Position, RenderSignal } from './types'\nimport { RenderPreset } from './presets/types';\n\ntype Item = { key: string, ngElement: NgElement }\n\ntype Renderer = {\n  get(element: HTMLElement): Item | undefined\n  mount(element: HTMLElement, key: string, component: any, injector: Injector, props: Record<string, unknown>): void\n  update(item: Item, props: Record<string, unknown>): void\n  unmount(element: HTMLElement): void\n}\nfunction getRenderer(): Renderer {\n  const elements = new WeakMap<HTMLElement, Item>()\n\n  return {\n    get(element) {\n      return elements.get(element)\n    },\n    mount(element, key, component, injector, props) {\n      // LIMITATION: If an element is remounted with the same identifier, the component cannot be replaced\n      const exists = customElements.get(key)\n\n      if (!exists) {\n        customElements.define(key, createCustomElement(component, { injector }))\n      }\n\n      const ngElement = document.createElement(key) as NodeProps & NgElement & typeof props\n\n      Object.keys(props).forEach(key => {\n        ngElement[key] = props[key]\n      })\n\n      element.appendChild(ngElement)\n      elements.set(element, { key, ngElement })\n    },\n    update({ ngElement }, props) {\n      Object.keys(props).forEach(key => {\n        ngElement.ngElementStrategy.setInputValue(key, props[key])\n      })\n      ngElement.ngElementStrategy.setInputValue('seed', Math.random())\n    },\n    unmount(element) {\n      const existing = elements.get(element)\n\n      if (existing) {\n        existing.ngElement.remove()\n        elements.delete(element)\n      }\n    }\n  }\n}\n\ntype Produces<Schemes extends BaseSchemes> =\n  | { type: 'connectionpath', data: { payload: Schemes['Connection'], path?: string, points: Position[] } }\n\ntype Requires<Schemes extends BaseSchemes> =\n  | RenderSignal<'node', { payload: Schemes['Node'] }>\n  | RenderSignal<'connection', { payload: Schemes['Connection'], start?: Position, end?: Position }>\n  | { type: 'unmount', data: { element: HTMLElement } }\n\nexport class AngularPlugin<Schemes extends BaseSchemes, T = Requires<Schemes>> extends Scope<Produces<Schemes>, [Requires<Schemes> | T]> {\n  presets: RenderPreset<Schemes, T>[] = []\n  renderer: Renderer\n  owners = new WeakMap<HTMLElement, RenderPreset<Schemes, T>>()\n\n  constructor(private params: { injector: Injector }) {\n    super('angular-render')\n    this.renderer = getRenderer()\n\n    this.addPipe(context => {\n      if (!context || typeof context !== 'object' || !('type' in context)) return context\n      if (context.type === 'unmount') {\n        this.unmount(context.data.element)\n      } else if (context.type === 'render') {\n        if ('filled' in context.data && context.data.filled) {\n          return context\n        }\n        if (this.mount(context.data.element, context)) {\n          return {\n            ...context,\n            data: {\n              ...context.data,\n              filled: true\n            }\n          } as typeof context\n        }\n      }\n      return context\n    })\n  }\n\n  setParent(scope: Scope<Requires<Schemes> | T>): void {\n    super.setParent(scope)\n\n    this.presets.forEach(preset => {\n      if (preset.attach) preset.attach(this)\n    })\n  }\n\n\n  private unmount(element: HTMLElement) {\n    this.owners.delete(element)\n    this.renderer.unmount(element)\n  }\n\n  private mount(element: HTMLElement, context: Requires<Schemes>) {\n    const existing = this.renderer.get(element)\n\n    if (existing) {\n      this.presets.forEach(preset => {\n        if (this.owners.get(element) !== preset) return\n        const result = preset.update(context as unknown as Extract<T, { type: 'render' }>, this)\n\n        if (result) {\n          this.renderer.update(existing, result)\n        }\n      })\n      return true\n    }\n\n    for (const preset of this.presets) {\n      const result = preset.mount(context as unknown as Extract<T, { type: 'render' }>, this)\n\n      if (!result) continue\n\n      const { key, component, props } = result\n\n      this.renderer.mount(element, key, component, this.params.injector, props)\n\n      this.owners.set(element, preset)\n      return true\n    }\n    return\n  }\n\n  public addPreset<K>(preset: RenderPreset<Schemes, CanAssignSignal<T, K> extends true ? K : 'Cannot apply preset. Provided signals are not compatible'>) {\n    const local = preset as unknown as RenderPreset<Schemes, T>\n\n    if (local.attach) local.attach(this)\n    this.presets.push(local)\n  }\n}\n"]}

package/15/esm2020/index.mjs

@@ -0,0 +1,11 @@
+export * as Presets from './presets';
+export { ReteModule } from './module';
+export { ReteContextMenuModule } from './presets/context-menu/module';
+export { ReteMinimapModule } from './presets/minimap/module';
+export { ReteRerouteModule } from './presets/reroute/module';
+export * from './presets/classic/components';
+export * from './presets/context-menu/components';
+export * from './presets/minimap/components';
+export * from './presets/reroute/components';
+export * from './core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9uZzE1L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLFdBQVcsQ0FBQTtBQUdwQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sVUFBVSxDQUFBO0FBRXJDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLCtCQUErQixDQUFBO0FBQ3JFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFBO0FBQzVELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBCQUEwQixDQUFBO0FBQzVELGNBQWMsOEJBQThCLENBQUE7QUFDNUMsY0FBYyxtQ0FBbUMsQ0FBQTtBQUNqRCxjQUFjLDhCQUE4QixDQUFBO0FBQzVDLGNBQWMsOEJBQThCLENBQUE7QUFDNUMsY0FBYyxRQUFRLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBhcyBQcmVzZXRzIGZyb20gJy4vcHJlc2V0cydcblxuZXhwb3J0IHsgQW5ndWxhckFyZWEyRCB9IGZyb20gJy4vcHJlc2V0cy9jbGFzc2ljL3R5cGVzJ1xuZXhwb3J0IHsgUmV0ZU1vZHVsZSB9IGZyb20gJy4vbW9kdWxlJ1xuZXhwb3J0IHsgUmVuZGVyUHJlc2V0IH0gZnJvbSAnLi9wcmVzZXRzL3R5cGVzJ1xuZXhwb3J0IHsgUmV0ZUNvbnRleHRNZW51TW9kdWxlIH0gZnJvbSAnLi9wcmVzZXRzL2NvbnRleHQtbWVudS9tb2R1bGUnXG5leHBvcnQgeyBSZXRlTWluaW1hcE1vZHVsZSB9IGZyb20gJy4vcHJlc2V0cy9taW5pbWFwL21vZHVsZSdcbmV4cG9ydCB7IFJldGVSZXJvdXRlTW9kdWxlIH0gZnJvbSAnLi9wcmVzZXRzL3Jlcm91dGUvbW9kdWxlJ1xuZXhwb3J0ICogZnJvbSAnLi9wcmVzZXRzL2NsYXNzaWMvY29tcG9uZW50cydcbmV4cG9ydCAqIGZyb20gJy4vcHJlc2V0cy9jb250ZXh0LW1lbnUvY29tcG9uZW50cydcbmV4cG9ydCAqIGZyb20gJy4vcHJlc2V0cy9taW5pbWFwL2NvbXBvbmVudHMnXG5leHBvcnQgKiBmcm9tICcuL3ByZXNldHMvcmVyb3V0ZS9jb21wb25lbnRzJ1xuZXhwb3J0ICogZnJvbSAnLi9jb3JlJ1xuIl19

package/15/esm2020/module.mjs

@@ -0,0 +1,56 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NodeComponent, RefDirective } from './presets/classic/components/node/node.component';
+import { ConnectionComponent } from './presets/classic/components/connection/connection.component';
+import { SocketComponent } from './presets/classic/components/socket/socket.component';
+import { ConnectionWrapperComponent } from './presets/classic/components/connection/connection-wrapper.component';
+import { ControlComponent } from './presets/classic/components/control/control.component';
+import * as i0 from "@angular/core";
+export class ReteModule {
+}
+ReteModule.ɵfac = function ReteModule_Factory(t) { return new (t || ReteModule)(); };
+ReteModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ReteModule });
+ReteModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ReteModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [
+                    RefDirective,
+                    NodeComponent,
+                    ConnectionComponent,
+                    ConnectionWrapperComponent,
+                    SocketComponent,
+                    ControlComponent
+                ],
+                imports: [
+                    CommonModule
+                ],
+                exports: [
+                    RefDirective,
+                    NodeComponent,
+                    ConnectionComponent,
+                    ConnectionWrapperComponent,
+                    SocketComponent,
+                    ControlComponent
+                ],
+                entryComponents: [
+                    NodeComponent,
+                    ConnectionComponent,
+                    ConnectionWrapperComponent,
+                    SocketComponent,
+                    ControlComponent
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ReteModule, { declarations: [RefDirective,
+        NodeComponent,
+        ConnectionComponent,
+        ConnectionWrapperComponent,
+        SocketComponent,
+        ControlComponent], imports: [CommonModule], exports: [RefDirective,
+        NodeComponent,
+        ConnectionComponent,
+        ConnectionWrapperComponent,
+        SocketComponent,
+        ControlComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/15/esm2020/presets/classic/components/connection/connection-wrapper.component.mjs

@@ -0,0 +1,79 @@
+import { Component, Input, ChangeDetectorRef, ViewContainerRef, ComponentFactoryResolver } from '@angular/core';
+import { ClassicPreset } from 'rete';
+import * as i0 from "@angular/core";
+export class ConnectionWrapperComponent {
+    constructor(cdr, viewContainerRef, componentFactoryResolver) {
+        this.cdr = cdr;
+        this.viewContainerRef = viewContainerRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.startOb = null;
+        this.endOb = null;
+        this.cdr.detach();
+    }
+    get _start() {
+        return 'x' in this.start ? this.start : this.startOb;
+    }
+    get _end() {
+        return 'x' in this.end ? this.end : this.endOb;
+    }
+    async ngOnChanges() {
+        await this.updatePath();
+        requestAnimationFrame(() => this.rendered());
+        this.cdr.detectChanges();
+        this.update();
+    }
+    async updatePath() {
+        if (this._start && this._end) {
+            this._path = await this.path(this._start, this._end);
+        }
+    }
+    ngOnInit() {
+        if (typeof this.start === 'function') {
+            this.start(async (value) => {
+                this.startOb = value;
+                await this.updatePath();
+                this.cdr.detectChanges();
+                this.update();
+            });
+        }
+        if (typeof this.end === 'function') {
+            this.end(async (value) => {
+                this.endOb = value;
+                await this.updatePath();
+                this.cdr.detectChanges();
+                this.update();
+            });
+        }
+        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(this.connectionComponent);
+        this.viewContainerRef.clear();
+        this.ref = this.viewContainerRef.createComponent(componentFactory);
+        this.update();
+    }
+    update() {
+        this.ref.instance.data = this.data;
+        this.ref.instance.start = this._start;
+        this.ref.instance.end = this._end;
+        this.ref.instance.path = this._path;
+    }
+}
+ConnectionWrapperComponent.ɵfac = function ConnectionWrapperComponent_Factory(t) { return new (t || ConnectionWrapperComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i0.ComponentFactoryResolver)); };
+ConnectionWrapperComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ConnectionWrapperComponent, selectors: [["ng-component"]], inputs: { data: "data", start: "start", end: "end", path: "path", rendered: "rendered", connectionComponent: "connectionComponent" }, features: [i0.ɵɵNgOnChangesFeature], decls: 0, vars: 0, template: function ConnectionWrapperComponent_Template(rf, ctx) { }, encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConnectionWrapperComponent, [{
+        type: Component,
+        args: [{
+                template: ''
+            }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ViewContainerRef }, { type: i0.ComponentFactoryResolver }]; }, { data: [{
+            type: Input
+        }], start: [{
+            type: Input
+        }], end: [{
+            type: Input
+        }], path: [{
+            type: Input
+        }], rendered: [{
+            type: Input
+        }], connectionComponent: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi13cmFwcGVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL25nMTUvc3JjL3ByZXNldHMvY2xhc3NpYy9jb21wb25lbnRzL2Nvbm5lY3Rpb24vY29ubmVjdGlvbi13cmFwcGVyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBVSxpQkFBaUIsRUFBYSxnQkFBZ0IsRUFBRSx3QkFBd0IsRUFBZ0IsTUFBTSxlQUFlLENBQUM7QUFDakosT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFRckMsTUFBTSxPQUFPLDBCQUEwQjtJQW9CckMsWUFBb0IsR0FBc0IsRUFBUyxnQkFBa0MsRUFBVSx3QkFBa0Q7UUFBN0gsUUFBRyxHQUFILEdBQUcsQ0FBbUI7UUFBUyxxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQWtCO1FBQVUsNkJBQXdCLEdBQXhCLHdCQUF3QixDQUEwQjtRQVZqSixZQUFPLEdBQW9CLElBQUksQ0FBQTtRQUkvQixVQUFLLEdBQW9CLElBQUksQ0FBQTtRQU8zQixJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRSxDQUFBO0lBQ25CLENBQUM7SUFYRCxJQUFJLE1BQU07UUFDUixPQUFPLEdBQUcsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFBO0lBQ3RELENBQUM7SUFFRCxJQUFJLElBQUk7UUFDTixPQUFPLEdBQUcsSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFBO0lBQ2hELENBQUM7SUFPRCxLQUFLLENBQUMsV0FBVztRQUNmLE1BQU0sSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFBO1FBQ3ZCLHFCQUFxQixDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFBO1FBQzVDLElBQUksQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUE7UUFDeEIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFBO0lBQ2YsQ0FBQztJQUVELEtBQUssQ0FBQyxVQUFVO1FBQ2QsSUFBSSxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDNUIsSUFBSSxDQUFDLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7U0FDckQ7SUFDSCxDQUFDO0lBRUQsUUFBUTtRQUNOLElBQUksT0FBTyxJQUFJLENBQUMsS0FBSyxLQUFLLFVBQVUsRUFBRTtZQUNwQyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBQyxLQUFLLEVBQUMsRUFBRTtnQkFDdkIsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUE7Z0JBQ3BCLE1BQU0sSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFBO2dCQUN2QixJQUFJLENBQUMsR0FBRyxDQUFDLGFBQWEsRUFBRSxDQUFBO2dCQUN4QixJQUFJLENBQUMsTUFBTSxFQUFFLENBQUE7WUFDZixDQUFDLENBQUMsQ0FBQTtTQUNIO1FBQ0QsSUFBSSxPQUFPLElBQUksQ0FBQyxHQUFHLEtBQUssVUFBVSxFQUFFO1lBQ2xDLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFDLEtBQUssRUFBQyxFQUFFO2dCQUNyQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQTtnQkFDbEIsTUFBTSxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUE7Z0JBQ3ZCLElBQUksQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUE7Z0JBQ3hCLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQTtZQUNmLENBQUMsQ0FBQyxDQUFBO1NBQ0g7UUFDRCxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyx1QkFBdUIsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsQ0FBQztRQUN6RyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFOUIsSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsZUFBZSxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDbkUsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFBO0lBQ2YsQ0FBQztJQUVELE1BQU07UUFDSixJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQTtRQUNsQyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQTtRQUNyQyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxHQUFHLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQTtRQUNqQyxJQUFJLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQTtJQUNyQyxDQUFDOztvR0FsRVUsMEJBQTBCOzZFQUExQiwwQkFBMEI7dUZBQTFCLDBCQUEwQjtjQUh0QyxTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFLEVBQUU7YUFDYjswSUFFVSxJQUFJO2tCQUFaLEtBQUs7WUFDRyxLQUFLO2tCQUFiLEtBQUs7WUFDRyxHQUFHO2tCQUFYLEtBQUs7WUFDRyxJQUFJO2tCQUFaLEtBQUs7WUFDRyxRQUFRO2tCQUFoQixLQUFLO1lBQ0csbUJBQW1CO2tCQUEzQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgT25Jbml0LCBDaGFuZ2VEZXRlY3RvclJlZiwgT25DaGFuZ2VzLCBWaWV3Q29udGFpbmVyUmVmLCBDb21wb25lbnRGYWN0b3J5UmVzb2x2ZXIsIENvbXBvbmVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ2xhc3NpY1ByZXNldCB9IGZyb20gJ3JldGUnO1xuaW1wb3J0IHsgUG9zaXRpb24gfSBmcm9tICcuLi8uLi8uLi8uLi90eXBlcyc7XG5cbnR5cGUgUG9zaXRpb25XYXRjaGVyID0gKGNiOiAodmFsdWU6IFBvc2l0aW9uKSA9PiB2b2lkKSA9PiAoKCkgPT4gdm9pZClcblxuQENvbXBvbmVudCh7XG4gIHRlbXBsYXRlOiAnJ1xufSlcbmV4cG9ydCBjbGFzcyBDb25uZWN0aW9uV3JhcHBlckNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCwgT25DaGFuZ2Vze1xuICBASW5wdXQoKSBkYXRhITogQ2xhc3NpY1ByZXNldC5Db25uZWN0aW9uPENsYXNzaWNQcmVzZXQuTm9kZSwgQ2xhc3NpY1ByZXNldC5Ob2RlPjtcbiAgQElucHV0KCkgc3RhcnQhOiBQb3NpdGlvbiB8IFBvc2l0aW9uV2F0Y2hlclxuICBASW5wdXQoKSBlbmQhOiBQb3NpdGlvbiB8IFBvc2l0aW9uV2F0Y2hlclxuICBASW5wdXQoKSBwYXRoITogKHN0YXJ0OiBQb3NpdGlvbiwgZW5kOiBQb3NpdGlvbikgPT4gUHJvbWlzZTxzdHJpbmc+XG4gIEBJbnB1dCgpIHJlbmRlcmVkITogYW55XG4gIEBJbnB1dCgpIGNvbm5lY3Rpb25Db21wb25lbnQhOiBhbnlcblxuICByZWYhOiBDb21wb25lbnRSZWY8YW55PlxuXG4gIHN0YXJ0T2I6IFBvc2l0aW9uIHwgbnVsbCA9IG51bGxcbiAgZ2V0IF9zdGFydCgpOiBQb3NpdGlvbiB8IG51bGwge1xuICAgIHJldHVybiAneCcgaW4gdGhpcy5zdGFydCA/IHRoaXMuc3RhcnQgOiB0aGlzLnN0YXJ0T2JcbiAgfVxuICBlbmRPYjogUG9zaXRpb24gfCBudWxsID0gbnVsbFxuICBnZXQgX2VuZCgpOiBQb3NpdGlvbiB8IG51bGwge1xuICAgIHJldHVybiAneCcgaW4gdGhpcy5lbmQgPyB0aGlzLmVuZCA6IHRoaXMuZW5kT2JcbiAgfVxuICBfcGF0aDogc3RyaW5nXG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBjZHI6IENoYW5nZURldGVjdG9yUmVmLCBwdWJsaWMgdmlld0NvbnRhaW5lclJlZjogVmlld0NvbnRhaW5lclJlZiwgcHJpdmF0ZSBjb21wb25lbnRGYWN0b3J5UmVzb2x2ZXI6IENvbXBvbmVudEZhY3RvcnlSZXNvbHZlcikgIHtcbiAgICB0aGlzLmNkci5kZXRhY2goKVxuICB9XG5cbiAgYXN5bmMgbmdPbkNoYW5nZXMoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgdGhpcy51cGRhdGVQYXRoKClcbiAgICByZXF1ZXN0QW5pbWF0aW9uRnJhbWUoKCkgPT4gdGhpcy5yZW5kZXJlZCgpKVxuICAgIHRoaXMuY2RyLmRldGVjdENoYW5nZXMoKVxuICAgIHRoaXMudXBkYXRlKClcbiAgfVxuXG4gIGFzeW5jIHVwZGF0ZVBhdGgoKSB7XG4gICAgaWYgKHRoaXMuX3N0YXJ0ICYmIHRoaXMuX2VuZCkge1xuICAgICAgdGhpcy5fcGF0aCA9IGF3YWl0IHRoaXMucGF0aCh0aGlzLl9zdGFydCwgdGhpcy5fZW5kKVxuICAgIH1cbiAgfVxuXG4gIG5nT25Jbml0KCkge1xuICAgIGlmICh0eXBlb2YgdGhpcy5zdGFydCA9PT0gJ2Z1bmN0aW9uJykge1xuICAgICAgdGhpcy5zdGFydChhc3luYyB2YWx1ZSA9PiB7XG4gICAgICAgIHRoaXMuc3RhcnRPYiA9IHZhbHVlXG4gICAgICAgIGF3YWl0IHRoaXMudXBkYXRlUGF0aCgpXG4gICAgICAgIHRoaXMuY2RyLmRldGVjdENoYW5nZXMoKVxuICAgICAgICB0aGlzLnVwZGF0ZSgpXG4gICAgICB9KVxuICAgIH1cbiAgICBpZiAodHlwZW9mIHRoaXMuZW5kID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICB0aGlzLmVuZChhc3luYyB2YWx1ZSA9PiB7XG4gICAgICAgIHRoaXMuZW5kT2IgPSB2YWx1ZVxuICAgICAgICBhd2FpdCB0aGlzLnVwZGF0ZVBhdGgoKVxuICAgICAgICB0aGlzLmNkci5kZXRlY3RDaGFuZ2VzKClcbiAgICAgICAgdGhpcy51cGRhdGUoKVxuICAgICAgfSlcbiAgICB9XG4gICAgY29uc3QgY29tcG9uZW50RmFjdG9yeSA9IHRoaXMuY29tcG9uZW50RmFjdG9yeVJlc29sdmVyLnJlc29sdmVDb21wb25lbnRGYWN0b3J5KHRoaXMuY29ubmVjdGlvbkNvbXBvbmVudCk7XG4gICAgdGhpcy52aWV3Q29udGFpbmVyUmVmLmNsZWFyKCk7XG5cbiAgICB0aGlzLnJlZiA9IHRoaXMudmlld0NvbnRhaW5lclJlZi5jcmVhdGVDb21wb25lbnQoY29tcG9uZW50RmFjdG9yeSk7XG4gICAgdGhpcy51cGRhdGUoKVxuICB9XG5cbiAgdXBkYXRlKCkge1xuICAgIHRoaXMucmVmLmluc3RhbmNlLmRhdGEgPSB0aGlzLmRhdGFcbiAgICB0aGlzLnJlZi5pbnN0YW5jZS5zdGFydCA9IHRoaXMuX3N0YXJ0XG4gICAgdGhpcy5yZWYuaW5zdGFuY2UuZW5kID0gdGhpcy5fZW5kXG4gICAgdGhpcy5yZWYuaW5zdGFuY2UucGF0aCA9IHRoaXMuX3BhdGhcbiAgfVxufVxuIl19

package/15/esm2020/presets/classic/components/connection/connection.component.mjs

@@ -0,0 +1,28 @@
+import { Component, Input } from '@angular/core';
+import { ClassicPreset } from 'rete';
+import * as i0 from "@angular/core";
+export class ConnectionComponent {
+}
+ConnectionComponent.ɵfac = function ConnectionComponent_Factory(t) { return new (t || ConnectionComponent)(); };
+ConnectionComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ConnectionComponent, selectors: [["connection"]], inputs: { data: "data", start: "start", end: "end", path: "path" }, decls: 2, vars: 1, consts: [["data-testid", "connection"]], template: function ConnectionComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵnamespaceSVG();
+        i0.ɵɵelementStart(0, "svg", 0);
+        i0.ɵɵelement(1, "path");
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵattribute("d", ctx.path);
+    } }, styles: ["svg[_ngcontent-%COMP%]{overflow:visible!important;position:absolute;pointer-events:none;width:9999px;height:9999px}svg[_ngcontent-%COMP%]   path[_ngcontent-%COMP%]{fill:none;stroke-width:5px;stroke:#4682b4;pointer-events:auto}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ConnectionComponent, [{
+        type: Component,
+        args: [{ selector: 'connection', template: "<svg data-testid=\"connection\">\n    <path [attr.d]=\"path\" />\n</svg>\n", styles: ["svg{overflow:visible!important;position:absolute;pointer-events:none;width:9999px;height:9999px}svg path{fill:none;stroke-width:5px;stroke:#4682b4;pointer-events:auto}\n"] }]
+    }], null, { data: [{
+            type: Input
+        }], start: [{
+            type: Input
+        }], end: [{
+            type: Input
+        }], path: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9uZzE1L3NyYy9wcmVzZXRzL2NsYXNzaWMvY29tcG9uZW50cy9jb25uZWN0aW9uL2Nvbm5lY3Rpb24uY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbmcxNS9zcmMvcHJlc2V0cy9jbGFzc2ljL2NvbXBvbmVudHMvY29ubmVjdGlvbi9jb25uZWN0aW9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBVXJDLE1BQU0sT0FBTyxtQkFBbUI7O3NGQUFuQixtQkFBbUI7c0VBQW5CLG1CQUFtQjtRQ1hoQyxtQkFBOEI7UUFBOUIsOEJBQThCO1FBQzFCLHVCQUF3QjtRQUM1QixpQkFBTTs7UUFESSxlQUFlO1FBQWYsNkJBQWU7O3VGRFVaLG1CQUFtQjtjQUwvQixTQUFTOzJCQUNFLFlBQVk7Z0JBS2IsSUFBSTtrQkFBWixLQUFLO1lBQ0csS0FBSztrQkFBYixLQUFLO1lBQ0csR0FBRztrQkFBWCxLQUFLO1lBQ0csSUFBSTtrQkFBWixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ2xhc3NpY1ByZXNldCB9IGZyb20gJ3JldGUnO1xuaW1wb3J0IHsgY2xhc3NpY0Nvbm5lY3Rpb25QYXRoIH0gZnJvbSAncmV0ZS1yZW5kZXItdXRpbHMnXG5pbXBvcnQgeyBQb3NpdGlvbiB9IGZyb20gJy4uLy4uLy4uLy4uL3R5cGVzJztcblxuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdjb25uZWN0aW9uJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2Nvbm5lY3Rpb24uY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9jb25uZWN0aW9uLmNvbXBvbmVudC5zYXNzJ11cbn0pXG5leHBvcnQgY2xhc3MgQ29ubmVjdGlvbkNvbXBvbmVudCB7XG4gIEBJbnB1dCgpIGRhdGEhOiBDbGFzc2ljUHJlc2V0LkNvbm5lY3Rpb248Q2xhc3NpY1ByZXNldC5Ob2RlLCBDbGFzc2ljUHJlc2V0Lk5vZGU+O1xuICBASW5wdXQoKSBzdGFydDogUG9zaXRpb25cbiAgQElucHV0KCkgZW5kOiBQb3NpdGlvblxuICBASW5wdXQoKSBwYXRoOiBzdHJpbmdcbn1cbiIsIjxzdmcgZGF0YS10ZXN0aWQ9XCJjb25uZWN0aW9uXCI+XG4gICAgPHBhdGggW2F0dHIuZF09XCJwYXRoXCIgLz5cbjwvc3ZnPlxuIl19