@maxdrellin/xenocline 0.0.1

package/dist/node/phasenode.d.ts

@@ -0,0 +1,21 @@
+import { Next } from '../transition/next';
+import { Context } from '../context';
+import { Input } from '../input';
+import { Output } from '../output';
+import { Phase } from '../phase';
+import { Node } from './node';
+export interface PhaseNode<I extends Input = Input, // Input to this phase instance
+O extends Output = Output> extends Node {
+    type: 'phase';
+    phase: Phase<I, O>;
+}
+export interface PhaseNodeOptions<O extends Output = Output, C extends Context = Context> {
+    next?: Next<O, C>;
+}
+export declare const DEFAULT_PHASE_NODE_OPTIONS: PhaseNodeOptions<Output, Context>;
+export declare const createPhaseNode: <I extends Input = Input, O extends Output = Output, C extends Context = Context>(id: string, phase: Phase<I, O>, options?: Partial<PhaseNodeOptions<O, C>>) => Readonly<PhaseNode<I, O>>;
+export declare const isPhaseNode: (obj: any) => obj is PhaseNode<any, any>;
+export declare const validatePhaseNode: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/node/phasenode.js

@@ -0,0 +1,35 @@
+import { isPhase } from '../phase.js';
+import { createNode, isNode } from './node.js';
+import { clean } from '../util/general.js';
+
+const DEFAULT_PHASE_NODE_OPTIONS = {};
+const createPhaseNode = (id, phase, options)=>{
+    let phaseNodeOptions = {
+        ...DEFAULT_PHASE_NODE_OPTIONS
+    };
+    if (options) {
+        phaseNodeOptions = {
+            ...phaseNodeOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createNode('phase', id, {
+            next: phaseNodeOptions.next
+        }),
+        phase
+    };
+};
+const isPhaseNode = (obj)=>{
+    if (!isNode(obj) || obj.type !== 'phase') {
+        return false;
+    }
+    const potentialPhaseNode = obj;
+    if (!(potentialPhaseNode.phase && typeof potentialPhaseNode.phase === 'object' && isPhase(potentialPhaseNode.phase))) {
+        return false;
+    }
+    return true;
+};
+
+export { DEFAULT_PHASE_NODE_OPTIONS, createPhaseNode, isPhaseNode };
+//# sourceMappingURL=phasenode.js.map

package/dist/node/phasenode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phasenode.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/output.d.ts

@@ -0,0 +1,6 @@
+export interface Output {
+    [key: string]: unknown;
+}
+export declare const EMPTY_OUTPUT: Output;
+export declare const isOutput: (output: unknown) => output is Output;
+export declare const validateOutput: (output: unknown) => output is Output;

package/dist/phase.d.ts

@@ -0,0 +1,16 @@
+import { Input } from './input';
+import { Output } from './output';
+export type ExecuteMethod<T extends Input = Input, U extends Output = Output> = (input: T) => Promise<U>;
+export interface Phase<T extends Input = Input, U extends Output = Output> {
+    name: string;
+    execute: (input: T) => Promise<U>;
+}
+export interface PhaseOptions<T extends Input = Input, U extends Output = Output> {
+    execute: ExecuteMethod<T, U>;
+}
+export declare const createPhase: <T extends Input = Input, U extends Output = Output>(name: string, options: Partial<PhaseOptions<T, U>>) => Readonly<Phase<T, U>>;
+export declare const isPhase: <T extends Input = Input, U extends Output = Output>(obj: any) => obj is Phase<T, U>;
+export declare const validatePhase: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/phase.js

@@ -0,0 +1,23 @@
+import { clean } from './util/general.js';
+
+const createPhase = (name, options)=>{
+    const defaultOptions = {
+        execute: async (input)=>{
+            return input;
+        }
+    };
+    const phaseOptions = {
+        ...defaultOptions,
+        ...clean(options)
+    };
+    return {
+        name,
+        execute: phaseOptions.execute
+    };
+};
+const isPhase = (obj)=>{
+    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.execute === 'function';
+};
+
+export { createPhase, isPhase };
+//# sourceMappingURL=phase.js.map

package/dist/phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/process.d.ts

@@ -0,0 +1,15 @@
+import { AggregatorNode } from './node/aggregatornode';
+import { PhaseNode } from './node/phasenode';
+export interface ProcessOptions {
+    phases: Record<string, PhaseNode | AggregatorNode>;
+}
+export interface Process {
+    name: string;
+    phases: Record<string, PhaseNode | AggregatorNode>;
+}
+export declare const createProcess: (name: string, options: Partial<ProcessOptions>) => Readonly<Process>;
+export declare const isProcess: (obj: any) => obj is Process;
+export declare const validateProcess: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/process.js

@@ -0,0 +1,106 @@
+import { validateNode } from './node/node.js';
+import { isConnection } from './transition/connection.js';
+import { clean } from './util/general.js';
+
+//import * as ClassifyPhase from './phases/classify';
+// import * as TranscribePhase from './phases/transcribe';
+// import * as ComposePhase from './phases/compose';
+// import * as CompletePhase from './phases/complete';
+const createProcess = (name, options)=>{
+    const defaultOptions = {
+        phases: {}
+    };
+    const processOptions = {
+        ...defaultOptions,
+        ...clean(options)
+    };
+    // Removed: const eventState = createEventState<C>(processOptions.eventHandlers);
+    return {
+        name,
+        phases: processOptions.phases
+    };
+};
+const isProcess = (obj)=>{
+    return obj !== undefined && obj !== null && typeof obj === 'object' && typeof obj.name === 'string' && typeof obj.phases === 'object';
+};
+const validateProcess = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...[],
+        'Process'
+    ];
+    if (item === undefined || item === null) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Process is undefined or null.'
+        });
+        return errors;
+    }
+    if (item.name === undefined || typeof item.name !== 'string') {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Process name is undefined or not a string.'
+        });
+    }
+    const processNameForPath = typeof item.name === 'string' ? item.name : 'UnnamedProcess';
+    const basePath = [
+        ...currentCoordinates,
+        `name:${processNameForPath}`
+    ];
+    if (item.phases === undefined || typeof item.phases !== 'object') {
+        errors.push({
+            coordinates: [
+                ...basePath,
+                'phases'
+            ],
+            error: 'Process phases is undefined or not an object.'
+        });
+    } else {
+        for(const phaseId in item.phases){
+            const node = item.phases[phaseId];
+            if (Object.prototype.hasOwnProperty.call(item.phases, phaseId)) {
+                errors.push(...validateNode(node, [
+                    ...basePath,
+                    'phases',
+                    phaseId
+                ]));
+            }
+        }
+        for(const phaseId in item.phases){
+            if (Object.prototype.hasOwnProperty.call(item.phases, phaseId)) {
+                const node = item.phases[phaseId];
+                if (node && typeof node === 'object' && node.next) {
+                    if (Array.isArray(node.next)) {
+                        const transitions = node.next;
+                        if (transitions.length > 0 && transitions.every((t)=>isConnection(t))) {
+                            transitions.forEach((connection, index)=>{
+                                if (connection && typeof connection.targetNodeId === 'string') {
+                                    if (!(connection.targetNodeId in item.phases)) {
+                                        errors.push({
+                                            coordinates: [
+                                                ...basePath,
+                                                'phases',
+                                                phaseId,
+                                                'next',
+                                                connection.id || `connection-at-index-${index}`
+                                            ],
+                                            error: `Node "${phaseId}" has a connection to non-existent targetNodeId "${connection.targetNodeId}".`
+                                        });
+                                    }
+                                } else if (!connection || connection.targetNodeId === undefined) ;
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return errors;
+};
+
+export { createProcess, isProcess, validateProcess };
+//# sourceMappingURL=process.js.map

package/dist/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/transition/beginning.d.ts

@@ -0,0 +1,19 @@
+import { Context } from '../context';
+import { Input } from '../input';
+import { Transition } from './transition';
+export type BeginFunction<I extends Input = Input, C extends Context = Context> = (input: I, context: C) => Promise<Input>;
+export interface Beginning<I extends Input = Input, C extends Context = Context> extends Transition {
+    type: 'beginning';
+    targetNodeId: string;
+    begin: BeginFunction<I, C>;
+}
+export interface BeginningOptions<I extends Input = Input, C extends Context = Context> {
+    begin: BeginFunction<I, C>;
+}
+export declare const DEFAULT_BEGINNING_OPTIONS: BeginningOptions<Input, Context>;
+export declare const createBeginning: <I extends Input = Input, C extends Context = Context>(id: string, targetNodeId: string, options?: Partial<BeginningOptions<I, C>>) => Readonly<Beginning<I, C>>;
+export declare const isBeginning: <I extends Input = Input, C extends Context = Context>(item: any) => item is Beginning<I, C>;
+export declare const validateBeginning: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/beginning.js

@@ -0,0 +1,31 @@
+import { clean } from '../util/general.js';
+import { createTransition, isTransition } from './transition.js';
+
+// NEW: Termination type extending Transition
+const DEFAULT_BEGINNING_OPTIONS = {
+    begin: async (input)=>{
+        return input;
+    }
+};
+const createBeginning = (id, targetNodeId, options)=>{
+    let beginningOptions = {
+        ...DEFAULT_BEGINNING_OPTIONS
+    };
+    if (options) {
+        beginningOptions = {
+            ...beginningOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createTransition('beginning', id),
+        targetNodeId,
+        begin: beginningOptions.begin
+    };
+};
+const isBeginning = (item)=>{
+    return isTransition(item) && item.type === 'beginning' && (item.begin === undefined || typeof item.begin === 'function');
+};
+
+export { DEFAULT_BEGINNING_OPTIONS, createBeginning, isBeginning };
+//# sourceMappingURL=beginning.js.map

package/dist/transition/beginning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"beginning.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/transition/connection.d.ts

@@ -0,0 +1,26 @@
+import { Input } from '../input';
+import { Context } from '../context';
+import { Output } from '../output';
+import { Transition } from './transition';
+export type TransformFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<[Input, C]>;
+export interface Connection<O extends Output = Output, C extends Context = Context> extends Transition {
+    type: 'connection';
+    targetNodeId: string;
+    transform: TransformFunction<O, C>;
+}
+export interface ConnectionOptions<O extends Output = Output, C extends Context = Context> {
+    transform: TransformFunction<O, C>;
+}
+export declare const DEFAULT_CONNECTION_OPTIONS: ConnectionOptions;
+export declare const createConnection: <O extends Output = Output, C extends Context = Context>(id: string, targetNodeId: string, options?: Partial<ConnectionOptions<O, C>>) => Readonly<Connection<O, C>>;
+export declare const isConnection: <O extends Output = Output, C extends Context = Context>(item: any) => item is Connection<O, C>;
+export declare const validateConnection: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;
+/**
+ * Event emitted specifically for connection transitions.
+ */
+export interface ConnectionEvent extends TransitionEvent {
+    transitionType: 'connection';
+}

package/dist/transition/connection.js

@@ -0,0 +1,80 @@
+import { createTransition, isTransition, validateTransition } from './transition.js';
+import { clean } from '../util/general.js';
+
+const DEFAULT_CONNECTION_OPTIONS = {
+    transform: async (output, context)=>{
+        return [
+            output,
+            context
+        ];
+    }
+};
+const createConnection = (id, targetNodeId, options)=>{
+    let connectionOptions = {
+        ...DEFAULT_CONNECTION_OPTIONS
+    };
+    if (options) {
+        connectionOptions = {
+            ...connectionOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createTransition('connection', id),
+        targetNodeId,
+        transform: connectionOptions.transform
+    };
+};
+const isConnection = (item)=>{
+    return isTransition(item) && item.type === 'connection' && item.targetNodeId !== undefined;
+};
+const validateConnection = (item, coordinates)=>{
+    const errors = [];
+    const connectionBaseCoordinates = [
+        ...coordinates || [],
+        'Connection'
+    ];
+    errors.push(...validateTransition(item, coordinates));
+    if (errors.length === 0) {
+        if (item && typeof item === 'object') {
+            const connectionSpecificErrorPath = [
+                ...connectionBaseCoordinates,
+                `Connection: ${item.id}`
+            ];
+            if (item.type === 'connection') {
+                if (typeof item.targetNodeId !== 'string') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Property "targetNodeId" must be a string when type is "connection".'
+                    });
+                }
+                // transform is optional, but if present, must be a function.
+                if (item.transform !== undefined && typeof item.transform !== 'function') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Optional property "transform" must be a function if present.'
+                    });
+                }
+            } else {
+                // If type is not 'connection', but these properties exist and are malformed.
+                // This primarily helps catch if a non-connection object has these fields incorrectly defined.
+                if (item.targetNodeId !== undefined && typeof item.targetNodeId !== 'string') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Property "targetNodeId" is present but is not a string.'
+                    });
+                }
+                if (item.transform !== undefined && typeof item.transform !== 'function') {
+                    errors.push({
+                        coordinates: connectionSpecificErrorPath,
+                        error: 'Property "transform" is present but is not a function.'
+                    });
+                }
+            }
+        }
+    }
+    return errors;
+};
+
+export { DEFAULT_CONNECTION_OPTIONS, createConnection, isConnection, validateConnection };
+//# sourceMappingURL=connection.js.map

package/dist/transition/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/transition/decision.d.ts

@@ -0,0 +1,20 @@
+import { Termination } from '../xenocline';
+import { Context } from '../context';
+import { Output } from '../output';
+import { Connection } from './connection';
+import { Transition } from './transition';
+export type DecideFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<Termination<O, C> | Connection<O, C>[]>;
+/**
+ * Represents a decision point in the process flow, taking a phase's output and context
+ * to determine the next step.
+ */
+export interface Decision<O extends Output = Output, C extends Context = Context> extends Transition {
+    type: 'decision';
+    decide: DecideFunction<O, C>;
+}
+export declare const createDecision: <O extends Output = Output, C extends Context = Context>(id: string, decide: DecideFunction<O, C>) => Readonly<Decision<O, C>>;
+export declare const isDecision: <O extends Output = Output, C extends Context = Context>(item: any) => item is Decision<O, C>;
+export declare const validateDecision: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/decision.js

@@ -0,0 +1,47 @@
+import { createTransition, isTransition, validateTransition } from './transition.js';
+
+const createDecision = (id, decide)=>{
+    return {
+        ...createTransition('decision', id),
+        decide
+    };
+};
+const isDecision = (item)=>{
+    return isTransition(item) && item.type === 'decision' && typeof item.decide === 'function';
+};
+const validateDecision = (item, coordinates)=>{
+    const errors = [];
+    const decisionBaseCoordinates = [
+        ...coordinates || [],
+        'Decision'
+    ];
+    errors.push(...validateTransition(item, coordinates));
+    if (errors.length === 0) {
+        if (item && typeof item === 'object') {
+            const decisionSpecificErrorPath = [
+                ...decisionBaseCoordinates,
+                `Decision: ${item.id}`
+            ];
+            if (item.type === 'decision') {
+                if (typeof item.decide !== 'function') {
+                    errors.push({
+                        coordinates: decisionSpecificErrorPath,
+                        error: 'Property "decide" must be a function when type is "decision".'
+                    });
+                }
+            } else {
+                // If type is not 'decision', but 'decide' property exists and is malformed.
+                if (item.decide !== undefined && typeof item.decide !== 'function') {
+                    errors.push({
+                        coordinates: decisionSpecificErrorPath,
+                        error: 'Property "decide" is present but is not a function.'
+                    });
+                }
+            }
+        }
+    }
+    return errors;
+};
+
+export { createDecision, isDecision, validateDecision };
+//# sourceMappingURL=decision.js.map

package/dist/transition/decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/transition/next.d.ts

@@ -0,0 +1,13 @@
+import { Output } from '../output';
+import { Context } from '../context';
+import { Termination } from './termination';
+import { Connection } from './connection';
+import { Decision } from './decision';
+type NonEmptyArray<T> = [T, ...T[]];
+export type Next<O extends Output = Output, C extends Context = Context> = Termination<O, C> | Readonly<NonEmptyArray<Connection<O, C>>> | Readonly<NonEmptyArray<Decision<O, C>>>;
+export declare const isNext: <O extends Output = Output, C extends Context = Context>(item: any) => item is Next<O, C>;
+export declare const validateNext: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;
+export {};

package/dist/transition/next.js

@@ -0,0 +1,81 @@
+import { validateTermination, isTermination } from './termination.js';
+import { isConnection, validateConnection } from './connection.js';
+import { isDecision, validateDecision } from './decision.js';
+
+const isNext = (item)=>{
+    if (isTermination(item)) {
+        return true;
+    }
+    if (!Array.isArray(item)) {
+        return false;
+    }
+    if (item.length === 0) {
+        return true;
+    }
+    const firstElement = item[0];
+    if (isConnection(firstElement)) {
+        return item.every((el)=>isConnection(el));
+    }
+    if (isDecision(firstElement)) {
+        return item.every((el)=>isDecision(el));
+    }
+    return false;
+};
+const validateDecisionOrConnectionArray = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || []
+    ];
+    if (item.length === 0) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Next Array is empty.'
+        });
+        return errors;
+    }
+    const firstElement = item[0];
+    if (isConnection(firstElement)) {
+        for (const element of item){
+            errors.push(...validateConnection(element, currentCoordinates));
+        }
+    } else if (isDecision(firstElement)) {
+        for (const element of item){
+            errors.push(...validateDecision(element, currentCoordinates));
+        }
+    } else {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Next Array contains invalid element types. Expected all Connections or all Decisions.'
+        });
+    }
+    return errors;
+};
+const validateNext = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || [],
+        'Next'
+    ];
+    if (item === undefined || item === null) {
+        errors.push({
+            coordinates: [
+                ...currentCoordinates
+            ],
+            error: 'Next is undefined or null.'
+        });
+        return errors;
+    }
+    if (Array.isArray(item)) {
+        errors.push(...validateDecisionOrConnectionArray(item, currentCoordinates));
+    } else {
+        errors.push(...validateTermination(item, currentCoordinates));
+    }
+    return errors;
+};
+
+export { isNext, validateNext };
+//# sourceMappingURL=next.js.map

package/dist/transition/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/transition/termination.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../context';
+import { Output } from '../output';
+import { Transition } from './transition';
+export type TerminateFunction<O extends Output = Output, C extends Context = Context> = (output: O, context: C) => Promise<Output>;
+export interface Termination<O extends Output = Output, C extends Context = Context> extends Transition {
+    type: 'termination';
+    terminate: TerminateFunction<O, C>;
+}
+export interface TerminationOptions<O extends Output = Output, C extends Context = Context> {
+    terminate: TerminateFunction<O, C>;
+}
+export declare const createTermination: <O extends Output = Output, C extends Context = Context>(id: string, options?: Partial<TerminationOptions<O, C>>) => Readonly<Termination<O, C>>;
+export declare const isTermination: <O extends Output = Output, C extends Context = Context>(item: any) => item is Termination<O, C>;
+export declare const validateTermination: (item: any, coordinates?: string[]) => Array<{
+    coordinates: string[];
+    error: string;
+}>;

package/dist/transition/termination.js

@@ -0,0 +1,50 @@
+import { clean } from '../util/general.js';
+import { createTransition, isTransition, validateTransition } from './transition.js';
+
+// NEW: Termination type extending Transition
+const createTermination = (id, options)=>{
+    const defaultOptions = {
+        terminate: async (output)=>{
+            return output;
+        }
+    };
+    let terminationOptions = {
+        ...defaultOptions
+    };
+    if (options) {
+        terminationOptions = {
+            ...terminationOptions,
+            ...clean(options)
+        };
+    }
+    return {
+        ...createTransition('termination', id),
+        terminate: terminationOptions.terminate
+    };
+};
+const isTermination = (item)=>{
+    return isTransition(item) && item.type === 'termination' && (item.terminate === undefined || typeof item.terminate === 'function');
+};
+const validateTermination = (item, coordinates)=>{
+    const errors = [];
+    const currentCoordinates = [
+        ...coordinates || [],
+        'Termination'
+    ];
+    errors.push(...validateTransition(item, currentCoordinates));
+    if (errors.length === 0) {
+        currentCoordinates.push(`Termination: ${item.id}`);
+        if (item.terminate !== undefined && typeof item.terminate !== 'function') {
+            errors.push({
+                coordinates: [
+                    ...currentCoordinates
+                ],
+                error: 'terminate is not a function.'
+            });
+        }
+    }
+    return errors;
+};
+
+export { createTermination, isTermination, validateTermination };
+//# sourceMappingURL=termination.js.map

package/dist/transition/termination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"termination.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}