pareto 0.51.1 → 0.53.0

package/auto.dist/public/shorthands/pareto.d.ts

@@ -0,0 +1,48 @@
+import * as pt from 'pareto-core-types';
+import * as g_pareto from "../glossaries/pareto";
+type RawOrNormalDictionary<T> = {
+    [key: string]: T;
+} | pt.Dictionary<T>;
+type RawArray<T> = T[];
+export declare function import_(path: string): g_pareto.D.Compilation__Unit.imports.DX;
+export declare function call(typeargs: RawOrNormalDictionary<g_pareto.D.Type__Arguments.DX>, context: g_pareto.D.Expression, args: RawOrNormalDictionary<g_pareto.D.Expression.selection.tail.A.call._larguments.DX>): g_pareto.D.Expression.selection.tail.A;
+export declare function property(name: string): g_pareto.D.Expression.selection.tail.A;
+export declare function variable(mut: 'mutable' | 'const', type: null | g_pareto.D.Type, expr: g_pareto.D.Expression): g_pareto.D.Variables.DX;
+export declare function type(typeparameters: RawOrNormalDictionary<g_pareto.D.Type__Parameters.DX>, type: g_pareto.D.Type): g_pareto.D.Namespace.types.DX;
+export declare function block(variables: RawOrNormalDictionary<g_pareto.D.Variables.DX>, statements: RawArray<g_pareto.D.Statement__Block.statements.A>): g_pareto.D.Statement__Block;
+export declare function ns(namespaces: RawOrNormalDictionary<g_pareto.D.Namespace.namespaces.DX>, types: RawOrNormalDictionary<g_pareto.D.Namespace.types.DX>, variables: RawOrNormalDictionary<g_pareto.D.Variables.DX>): g_pareto.D.Namespace;
+export declare const sel: {
+    context: (tail: RawArray<g_pareto.D.Expression.selection.tail.A>) => g_pareto.D.Expression.selection;
+    parameter: (parameter: string, tail: RawArray<g_pareto.D.Expression.selection.tail.A>) => g_pareto.D.Expression.selection;
+    variable: (import_: null | string, nsPath: RawArray<g_pareto.D.Expression.selection.start.variable.namespace__path.A>, variable: string, tail: RawArray<g_pareto.D.Expression.selection.tail.A>) => g_pareto.D.Expression.selection;
+};
+export declare const e: {
+    array: (elements: RawArray<g_pareto.D.Expression.array__literal.A>) => g_pareto.D.Expression;
+    contextSelection: (tail: RawArray<g_pareto.D.Expression.selection.tail.A>) => g_pareto.D.Expression;
+    block: (block: g_pareto.D.Statement__Block) => g_pareto.D.Expression;
+    dictionary: (properties: RawOrNormalDictionary<g_pareto.D.Expression.dictionary__literal.DX>) => g_pareto.D.Expression;
+    group: (properties: RawOrNormalDictionary<g_pareto.D.Expression.dictionary__literal.DX>) => g_pareto.D.Expression;
+    implementMe: (message: string) => g_pareto.D.Expression;
+    nonTypedFunction: (hasparameters: boolean, block: g_pareto.D.Statement__Block) => g_pareto.D.Expression;
+    null: () => g_pareto.D.Expression;
+    parameterSelection: (parameter: string, tail: RawArray<g_pareto.D.Expression.selection.tail.A>) => g_pareto.D.Expression;
+    select: (type: g_pareto.D.Expression.selection) => g_pareto.D.Expression;
+    state: (state: string, data: g_pareto.D.Expression) => g_pareto.D.Expression;
+    string: (string: string) => g_pareto.D.Expression;
+    switch: (select: g_pareto.D.Expression, cases: RawOrNormalDictionary<g_pareto.D.Expression._lswitch.cases.DX>, default_: null | g_pareto.D.Expression) => g_pareto.D.Expression;
+    typedFunction: (typeparameters: RawOrNormalDictionary<g_pareto.D.Type__Parameters.DX>, contextparameter: g_pareto.D.Function__Signature.context__parameter, parameters: RawOrNormalDictionary<g_pareto.D.Function__Signature.parameters.DX>, returntype: null | g_pareto.D.Function__Signature.return__type.O, block: g_pareto.D.Statement__Block) => g_pareto.D.Expression;
+    variableSelection: (import_: null | string, nsPath: RawArray<g_pareto.D.Expression.selection.start.variable.namespace__path.A>, variable: string, tail: RawArray<g_pareto.D.Expression.selection.tail.A>) => g_pareto.D.Expression;
+};
+export declare const s: {
+    expr: (expr: g_pareto.D.Expression) => g_pareto.D.Statement__Block.statements.A;
+    return: (expr: g_pareto.D.Expression) => g_pareto.D.Statement__Block.statements.A;
+};
+export declare const t: {
+    function: (typeparameters: RawOrNormalDictionary<g_pareto.D.Type__Parameters.DX>, contextparameter: g_pareto.D.Function__Signature.context__parameter, parameters: RawOrNormalDictionary<g_pareto.D.Function__Signature.parameters.DX>, returntype: null | g_pareto.D.Function__Signature.return__type.O) => g_pareto.D.Type;
+    group: (members: RawOrNormalDictionary<g_pareto.D.Type.group.members.DX>) => g_pareto.D.Type;
+    null: () => g_pareto.D.Type;
+    parameter: (parameter: string) => g_pareto.D.Type;
+    string: () => g_pareto.D.Type;
+    typeSelection: (import_: null | string, nsPath: RawArray<g_pareto.D.Expression.selection.start.variable.namespace__path.A>, type: string, typeargs: RawOrNormalDictionary<g_pareto.D.Type__Arguments.DX>) => g_pareto.D.Type;
+};
+export {};

package/auto.dist/public/shorthands/pareto.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = exports.s = exports.e = exports.sel = void 0;
+exports.import_ = import_;
+exports.call = call;
+exports.property = property;
+exports.variable = variable;
+exports.type = type;
+exports.block = block;
+exports.ns = ns;
+const pa = __importStar(require("pareto-core-alg"));
+const d = pa.wrapRawDictionary;
+const a = pa.wrapRawArray;
+function toNormalDict($) {
+    function isNormal($) {
+        return $.__forEach !== undefined && typeof $.__forEach === "function";
+    }
+    if (isNormal($)) {
+        return $;
+    }
+    else {
+        return d($);
+    }
+}
+function import_(path) {
+    return { 'path': path };
+}
+function call(typeargs, context, args) {
+    return ['call', {
+            'type arguments': toNormalDict(typeargs),
+            'context': context,
+            'arguments': toNormalDict(args),
+        }];
+}
+function property(name) {
+    return ['member selection', name];
+}
+function variable(mut, type, expr) {
+    return {
+        'mutable': mut === 'mutable',
+        'type': type === null ? pa.notSet() : pa.set(type),
+        'expression': expr
+    };
+}
+function type(typeparameters, type) {
+    return {
+        'type': type,
+        'type parameters': toNormalDict(typeparameters)
+    };
+}
+function block(variables, statements) {
+    return {
+        'variables': toNormalDict(variables),
+        'statements': a(statements),
+    };
+}
+function ns(namespaces, types, variables) {
+    return {
+        'namespaces': toNormalDict(namespaces),
+        'types': toNormalDict(types),
+        'variables': toNormalDict(variables),
+    };
+}
+exports.sel = {
+    'context': (tail) => {
+        return {
+            'start': ['context', null],
+            'tail': a(tail),
+        };
+    },
+    'parameter': (parameter, tail) => {
+        return {
+            'start': ['parameter', parameter],
+            'tail': a(tail),
+        };
+    },
+    'variable': (import_, nsPath, variable, tail) => {
+        return {
+            'start': ['variable', {
+                    'import': import_ === null ? pa.notSet() : pa.set(import_),
+                    'namespace path': a(nsPath),
+                    'variable': variable,
+                }],
+            'tail': a(tail),
+        };
+    },
+};
+exports.e = {
+    'array': (elements) => {
+        return ['array literal', a(elements)];
+    },
+    'contextSelection': (tail) => {
+        return ['selection', {
+                'start': ['context', null],
+                'tail': a(tail),
+            }];
+    },
+    'block': (block) => {
+        return ['block', block];
+    },
+    'dictionary': (properties) => {
+        return ['dictionary literal', toNormalDict(properties)];
+    },
+    'group': (properties) => {
+        return ['group literal', toNormalDict(properties)];
+    },
+    'implementMe': (message) => {
+        return ['implement me', message];
+    },
+    'nonTypedFunction': (hasparameters, block) => {
+        return ['function', {
+                'temp signature help': hasparameters ? ['has additional parameters', null] : ['has no additional parameters', null],
+                'block': block,
+            }];
+    },
+    'null': () => {
+        return ['null literal', null];
+    },
+    'parameterSelection': (parameter, tail) => {
+        return ['selection', {
+                'start': ['parameter', parameter],
+                'tail': a(tail),
+            }];
+    },
+    'select': (type) => {
+        return ['selection', type];
+    },
+    'state': (state, data) => {
+        return ['state literal', {
+                'state': state,
+                'data': data
+            }];
+    },
+    'string': (string) => {
+        return ['string literal', string];
+    },
+    'switch': (select, cases, default_) => {
+        return ['switch', {
+                'select': select,
+                'cases': toNormalDict(cases),
+                'default': default_ === null ? pa.notSet() : pa.set(default_)
+            }];
+    },
+    'typedFunction': (typeparameters, contextparameter, parameters, returntype, block) => {
+        return ['function', {
+                'temp signature help': ['typed', {
+                        'type parameters': toNormalDict(typeparameters),
+                        'context parameter': contextparameter,
+                        'parameters': toNormalDict(parameters),
+                        'return type': returntype === null ? pa.notSet() : pa.set(returntype),
+                    }],
+                'block': block,
+            }];
+    },
+    'variableSelection': (import_, nsPath, variable, tail) => {
+        return ['selection', {
+                'start': ['variable', {
+                        'import': import_ === null ? pa.notSet() : pa.set(import_),
+                        'namespace path': a(nsPath),
+                        'variable': variable,
+                    }],
+                'tail': a(tail),
+            }];
+    },
+};
+exports.s = {
+    'expr': (expr) => {
+        return ['expression', expr];
+    },
+    'return': (expr) => {
+        return ['return', {
+                'expression': expr,
+            }];
+    },
+};
+exports.t = {
+    'function': (typeparameters, contextparameter, parameters, returntype) => {
+        return ['function', {
+                'type parameters': toNormalDict(typeparameters),
+                'context parameter': contextparameter,
+                'parameters': toNormalDict(parameters),
+                'return type': returntype === null ? pa.notSet() : pa.set(returntype),
+            }];
+    },
+    'group': (members) => {
+        return ['group', {
+                'members': toNormalDict(members)
+            }];
+    },
+    'null': () => {
+        return ['null', null];
+    },
+    'parameter': (parameter) => {
+        return ['parameter selection', parameter];
+    },
+    'string': () => {
+        return ['string', null];
+    },
+    'typeSelection': (import_, nsPath, type, typeargs) => {
+        return ['type selection', {
+                'import': import_ === null ? pa.notSet() : pa.set(import_),
+                'namespace path': a(nsPath),
+                'type': type,
+                'type arguments': toNormalDict(typeargs),
+            }];
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pareto.js","sourceRoot":"","sources":["../../../src/public/shorthands/pareto.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,0BAEC;AAED,oBAUC;AACD,4BAIC;AAED,4BAUC;AAED,oBAQC;AAED,sBAQC;AAED,gBAUC;AAtFD,oDAAqC;AAKrC,MAAM,CAAC,GAAG,EAAE,CAAC,iBAAiB,CAAA;AAC9B,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAA;AAKzB,SAAS,YAAY,CAAI,CAA2B;IAChD,SAAS,QAAQ,CAAC,CAA2B;QACzC,OAAO,CAAC,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,CAAC,CAAC,SAAS,KAAK,UAAU,CAAA;IACzE,CAAC;IACD,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QACd,OAAO,CAAC,CAAA;IACZ,CAAC;SAAM,CAAC;QACJ,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;IACf,CAAC;AACL,CAAC;AAGD,SAAgB,OAAO,CAAC,IAAY;IAChC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;AAC3B,CAAC;AAED,SAAgB,IAAI,CAChB,QAA8D,EAC9D,OAA8B,EAC9B,IAAuF;IAEvF,OAAO,CAAC,MAAM,EAAE;YACZ,gBAAgB,EAAE,YAAY,CAAC,QAAQ,CAAC;YACxC,SAAS,EAAE,OAAO;YAClB,WAAW,EAAE,YAAY,CAAC,IAAI,CAAC;SAClC,CAAC,CAAA;AACN,CAAC;AACD,SAAgB,QAAQ,CACpB,IAAY;IAEZ,OAAO,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAA;AACrC,CAAC;AAED,SAAgB,QAAQ,CACpB,GAAwB,EACxB,IAA4B,EAC5B,IAA2B;IAE3B,OAAO;QACH,SAAS,EAAE,GAAG,KAAK,SAAS;QAC5B,MAAM,EAAE,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;QAClD,YAAY,EAAE,IAAI;KACrB,CAAA;AACL,CAAC;AAED,SAAgB,IAAI,CAChB,cAAqE,EACrE,IAAqB;IAErB,OAAO;QACH,MAAM,EAAE,IAAI;QACZ,iBAAiB,EAAE,YAAY,CAAC,cAAc,CAAC;KAClD,CAAA;AACL,CAAC;AAED,SAAgB,KAAK,CACjB,SAAyD,EACzD,UAA8D;IAE9D,OAAO;QACH,WAAW,EAAE,YAAY,CAAC,SAAS,CAAC;QACpC,YAAY,EAAE,CAAC,CAAC,UAAU,CAAC;KAC9B,CAAA;AACL,CAAC;AAED,SAAgB,EAAE,CACd,UAAqE,EACrE,KAA2D,EAC3D,SAAyD;IAEzD,OAAO;QACH,YAAY,EAAE,YAAY,CAAC,UAAU,CAAC;QACtC,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC;QAC5B,WAAW,EAAE,YAAY,CAAC,SAAS,CAAC;KACvC,CAAA;AACL,CAAC;AAEY,QAAA,GAAG,GAAG;IACf,SAAS,EAAE,CACP,IAAsD,EACvB,EAAE;QACjC,OAAO;YACH,OAAO,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC;YAC1B,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;SAClB,CAAA;IACL,CAAC;IACD,WAAW,EAAE,CACT,SAAiB,EACjB,IAAsD,EACvB,EAAE;QACjC,OAAO;YACH,OAAO,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC;YACjC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;SAClB,CAAA;IACL,CAAC;IACD,UAAU,EAAE,CACR,OAAsB,EACtB,MAAkF,EAClF,QAAgB,EAChB,IAAsD,EACvB,EAAE;QACjC,OAAO;YACH,OAAO,EAAE,CAAC,UAAU,EAAE;oBAClB,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC;oBAC1D,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC;oBAC3B,UAAU,EAAE,QAAQ;iBACvB,CAAC;YACF,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;SAClB,CAAA;IACL,CAAC;CAEJ,CAAA;AAEY,QAAA,CAAC,GAAG;IACb,OAAO,EAAE,CACL,QAA0D,EACrC,EAAE;QACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;IACzC,CAAC;IACD,kBAAkB,EAAE,CAChB,IAAsD,EACjC,EAAE;QACvB,OAAO,CAAC,WAAW,EAAE;gBACjB,OAAO,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC;gBAC1B,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;aAClB,CAAC,CAAA;IACN,CAAC;IACD,OAAO,EAAE,CACL,KAAkC,EACb,EAAE;QACvB,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAC3B,CAAC;IACD,YAAY,EAAE,CACV,UAA+E,EAC1D,EAAE;QACvB,OAAO,CAAC,oBAAoB,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAA;IAC3D,CAAC;IACD,OAAO,EAAE,CACL,UAA+E,EAC1D,EAAE;QACvB,OAAO,CAAC,eAAe,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAA;IACtD,CAAC;IACD,aAAa,EAAE,CAAC,OAAe,EAAyB,EAAE;QACtD,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,CAAA;IACpC,CAAC;IACD,kBAAkB,EAAE,CAChB,aAAsB,EACtB,KAAkC,EACb,EAAE;QACvB,OAAO,CAAC,UAAU,EAAE;gBAChB,qBAAqB,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,2BAA2B,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,8BAA8B,EAAE,IAAI,CAAC;gBACnH,OAAO,EAAE,KAAK;aACjB,CAAC,CAAA;IACN,CAAC;IACD,MAAM,EAAE,GAA0B,EAAE;QAChC,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,CAAA;IACjC,CAAC;IACD,oBAAoB,EAAE,CAClB,SAAiB,EACjB,IAAsD,EACjC,EAAE;QACvB,OAAO,CAAC,WAAW,EAAE;gBACjB,OAAO,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC;gBACjC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;aAClB,CAAC,CAAA;IACN,CAAC;IACD,QAAQ,EAAE,CACN,IAAqC,EAChB,EAAE;QACvB,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;IAC9B,CAAC;IACD,OAAO,EAAE,CACL,KAAa,EACb,IAA2B,EACN,EAAE;QACvB,OAAO,CAAC,eAAe,EAAE;gBACrB,OAAO,EAAE,KAAK;gBACd,MAAM,EAAE,IAAI;aACf,CAAC,CAAA;IACN,CAAC;IACD,QAAQ,EAAE,CAAC,MAAc,EAAyB,EAAE;QAChD,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAA;IACrC,CAAC;IACD,QAAQ,EAAE,CACN,MAA6B,EAC7B,KAAqE,EACrE,QAAsC,EACjB,EAAE;QACvB,OAAO,CAAC,QAAQ,EAAE;gBACd,QAAQ,EAAE,MAAM;gBAChB,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC;gBAC5B,SAAS,EAAE,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC;aAChE,CAAC,CAAA;IACN,CAAC;IACD,eAAe,EAAE,CACb,cAAqE,EACrE,gBAAmE,EACnE,UAA+E,EAC/E,UAAgE,EAChE,KAAkC,EACb,EAAE;QACvB,OAAO,CAAC,UAAU,EAAE;gBAChB,qBAAqB,EAAE,CAAC,OAAO,EAAE;wBAC7B,iBAAiB,EAAE,YAAY,CAAC,cAAc,CAAC;wBAC/C,mBAAmB,EAAE,gBAAgB;wBACrC,YAAY,EAAE,YAAY,CAAC,UAAU,CAAC;wBACtC,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;qBACxE,CAAC;gBACF,OAAO,EAAE,KAAK;aACjB,CAAC,CAAA;IACN,CAAC;IACD,mBAAmB,EAAE,CACjB,OAAsB,EACtB,MAAkF,EAClF,QAAgB,EAChB,IAAsD,EACjC,EAAE;QACvB,OAAO,CAAC,WAAW,EAAE;gBACjB,OAAO,EAAE,CAAC,UAAU,EAAE;wBAClB,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC;wBAC1D,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC;wBAC3B,UAAU,EAAE,QAAQ;qBACvB,CAAC;gBACF,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC;aAClB,CAAC,CAAA;IACN,CAAC;CACJ,CAAA;AAEY,QAAA,CAAC,GAAG;IACb,MAAM,EAAE,CAAC,IAA2B,EAA4C,EAAE;QAC9E,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,CAAA;IAC/B,CAAC;IACD,QAAQ,EAAE,CAAC,IAA2B,EAA4C,EAAE;QAChF,OAAO,CAAC,QAAQ,EAAE;gBACd,YAAY,EAAE,IAAI;aACrB,CAAC,CAAA;IACN,CAAC;CACJ,CAAA;AAEY,QAAA,CAAC,GAAG;IACb,UAAU,EAAE,CACR,cAAqE,EACrE,gBAAmE,EACnE,UAA+E,EAC/E,UAAgE,EACjD,EAAE;QACjB,OAAO,CAAC,UAAU,EAAE;gBAChB,iBAAiB,EAAE,YAAY,CAAC,cAAc,CAAC;gBAC/C,mBAAmB,EAAE,gBAAgB;gBACrC,YAAY,EAAE,YAAY,CAAC,UAAU,CAAC;gBACtC,aAAa,EAAE,UAAU,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;aAExE,CAAC,CAAA;IACN,CAAC;IACD,OAAO,EAAE,CAAC,OAAgE,EAAmB,EAAE;QAC3F,OAAO,CAAC,OAAO,EAAE;gBACb,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC;aACnC,CAAC,CAAA;IACN,CAAC;IACD,MAAM,EAAE,GAAoB,EAAE;QAC1B,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACzB,CAAC;IACD,WAAW,EAAE,CACT,SAAiB,EACF,EAAE;QACjB,OAAO,CAAC,qBAAqB,EAAE,SAAS,CAAC,CAAA;IAC7C,CAAC;IACD,QAAQ,EAAE,GAAoB,EAAE;QAC5B,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;IAC3B,CAAC;IACD,eAAe,EAAE,CACb,OAAsB,EACtB,MAAkF,EAClF,IAAY,EACZ,QAA8D,EAE/C,EAAE;QACjB,OAAO,CAAC,gBAAgB,EAAE;gBACtB,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC;gBAC1D,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC;gBAC3B,MAAM,EAAE,IAAI;gBACZ,gBAAgB,EAAE,YAAY,CAAC,QAAQ,CAAC;aAC3C,CAAC,CAAA;IACN,CAAC;CACJ,CAAA"}

package/auto.pareto/$.data.ts

@@ -0,0 +1,45 @@
+import * as pd from 'pareto-core-data'
+import * as pt from 'pareto-core-types'
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+import { } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import { $ as d_cosmos_type_system } from "./glossaries/auto.cosmos_type_system.data"
+import { $ as d_pareto } from "./glossaries/auto.pareto.data"
+
+import { $ as d_fountain_pen } from "./modules/fountain_pen/api.data"
+import { $ as d_cosmos2pareto } from "./modules/cosmos2pareto/api.data"
+import { $ as d_pareto2typescript } from "./modules/pareto2typescript/api.data"
+
+
+import { $ as d_dependencies } from "./auto.dependencies"
+
+export const $: g_project.D.Library<pd.SourceLocation> = {
+    'author': "Corno",
+    'description': "",
+    'license': "TBD",
+
+    'type': ['pure', {
+        'dependencies': d_dependencies,
+    }],
+    'module sets': {
+        'public': {
+            'glossaries': d({
+                "cosmos type system": d_cosmos_type_system,
+                "pareto": d_pareto,
+            }),
+            'modules': d({
+                "fountain pen": d_fountain_pen,
+                "cosmos 2 pareto": d_cosmos2pareto,
+                "pareto 2 typescript": d_pareto2typescript,
+            }),
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({
+            }),
+        }
+    }
+}

package/auto.pareto/auto.dependencies/index.ts

@@ -0,0 +1,9 @@
+import * as pd from 'pareto-core-data'
+
+import { $ as dep_pareto_standard_impure_library } from './pareto-standard-impure-library/$.data'
+import { $ as dep_res_typescript } from './res-typescript/$.data'
+
+export const $ = pd.d({
+    'pareto-standard-impure-library': { library: dep_pareto_standard_impure_library, version: '^0.9.0' },
+    'res-typescript': { library: dep_res_typescript, version: '^0.35.0' },
+})

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/$.data.ts

@@ -0,0 +1,58 @@
+import * as pd from 'pareto-core-data'
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+import { } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
+import { $ as d_array } from "./modules/array/api.data"
+import { $ as d_boolean } from "./modules/boolean/api.data"
+import { $ as d_build } from "./modules/build/api.data"
+import { $ as d_collation } from "./modules/collation/api.data"
+import { $ as d_dictionary } from "./modules/dictionary/api.data"
+import { $ as d_filesystem } from "./modules/filesystem/api.data"
+import { $ as d_foreach } from "./modules/foreach/api.data"
+import { $ as d_http } from "./modules/http/api.data"
+import { $ as d_json } from "./modules/json/api.data"
+import { $ as d_path } from "./modules/path/api.data"
+import { $ as d_nested } from "./modules/nested/api.data"
+import { $ as d_numerical_predicates } from "./modules/numerical_predicates/api.data"
+import { $ as d_resolve } from "./modules/resolve/api.data"
+import { $ as d_string } from "./modules/string/api.data"
+import { $ as d_tostring } from "./modules/tostring/api.data"
+
+export const $: g_project.D.Library<pd.SourceLocation> = {
+    'author': "Corno",
+    'description': "A library that contains very common functionality that cannot be implemented purely in Pareto",
+    'license': "TBD",
+
+    'type': ['impure', null],
+    'module sets': {
+        'public': {
+            'glossaries': d({}),
+            'modules': d({
+                "arithmetic": d_arithmetic,
+                "array": d_array,
+                "boolean": d_boolean,
+                "build": d_build,
+                "collation": d_collation,
+                "dictionary": d_dictionary,
+                "filesystem": d_filesystem,
+                "foreach": d_foreach,
+                "http": d_http,
+                "json": d_json,
+                "nested": d_nested,
+                "numerical predicates": d_numerical_predicates,
+                "path": d_path,
+                "resolve": d_resolve,
+                "string": d_string,
+                "tostring": d_tostring,
+            })
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({}),
+        }
+    }
+}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/arithmetic/api.data.ts

@@ -0,0 +1,26 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "arrayMax": algorithm("ArrayMax", null, {}),
+        "arrayMin": algorithm("ArrayMin", null, {}),
+        "arraySum": algorithm("ArraySum", null, {}),
+        "dictionaryMax": algorithm("DictionaryMax", null, {}),
+        "dictionaryMin": algorithm("DictionaryMin", null, {}),
+        "dictionarySum": algorithm("DictionarySum", null, {}),
+        "divideWithRemainder": algorithm("DivideWithRemainder", null, {}),
+        "increment": algorithm("Increment", "IncrementConfig", {}),
+        "max": algorithm("Max", null, {}),
+        "array_multiply": algorithm("Array Multiply", null, {}),
+        "negate": algorithm("Negate", null, {}),
+        "subtract": algorithm("Subtract", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/arithmetic/glossary.data.ts

@@ -0,0 +1,76 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
+    type, typeReference
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Number": type(number()),
+            "OptionalNumber": type(optional(number())),
+            "NumberRange": type(array(number())),
+            "DivisionData": type(group({
+                "numerator": member(number()),
+                "denominator": member(number()),
+            })),
+            "NumberTuple": type(group({
+                "yin": member(number()),
+                "yang": member(number()),
+            })),
+            "DivisionResult": type(optional(group({
+                "quotient": member(number()),
+                "remainder": member(number()),
+
+            }))),
+            "SubtractData": type(group({
+                "minuend": member(number()),
+                "subtrahend": member(number()),
+            })),
+            "NumberDictionary": type(dictionary(number())),
+            "NumberArray": type(array(number())),
+
+            "IncrementConfig": type(group({
+                "stepsize": member(number())
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Increment": sfunction(typeReference("Number"), data(typeReference("Number"))),
+        "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
+        "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
+        /**
+        * if the denominator is 0, the return value is null
+        * (division by 0),
+        */
+        "DivideWithRemainder": sfunction(typeReference("DivisionResult"), data(typeReference("DivisionData"))),
+        /**
+         * calculates the max of an array of numbers. If there are no entries, the result value is 0
+         */
+        "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
+        /**
+         * calculates the max of a dictionary of number. If there are no entries, the result value is 0
+         */
+        "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        /**
+        * calculates the max of a tuple of numbers
+        */
+        "DictionarySum": sfunction(typeReference("Number"), data(typeReference("NumberDictionary"))),
+
+        "Max": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
+        "Subtract": sfunction(typeReference("Number"), data(typeReference("SubtractData"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/array/api.data.ts

@@ -0,0 +1,21 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "getLastElement": algorithm("GetLastElement", null, {}),
+        //FIXME "getElementAt": algorithm("GetElementAt", null, {}),
+        "getLength": algorithm("GetLength", null, {}),
+        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", null, {}),
+        "push": algorithm("Push", null, {}),
+        "matchArrays": algorithm("MatchArrays", null, {}),
+
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/array/glossary.data.ts

@@ -0,0 +1,60 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
+    type, typeParameter, typeReference
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Length": type(number()),
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+            "ArrayOfArrays": parametrizedType({ "Type": null }, array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+            "GetElementAtData": parametrizedType({ "Type": null }, group({
+                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                "index": member(number()),
+            })),
+            "PushParameters": parametrizedType({ "Type": null }, group({
+                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                "element": member(ref(typeParameter("Type"))),
+            })),
+            "OptionalElement": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+
+
+            "ArrayTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+            })),
+
+            "MatchedArrays": parametrizedType({ "Benchmark": null, "Focus": null }, array(group({
+                "benchmark": member(ref(typeParameter("Benchmark"))),
+                "focus": member(ref(typeParameter("Focus"))),
+            }))),
+
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "GetElementAt": sfunction(typeParameter("Type"), data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })), { "Type": null }),
+        "GetLastElement": sfunction(typeReference("OptionalElement", { "Type": typeParameter("Type") }), data(typeReference("Array", { "Type": typeParameter("Type") })), { "Type": null }),
+        "GetLength": sfunction(typeReference("Length"), data(typeReference("Array", { "Type": typeParameter("Type") })), { "Type": null }),
+        "FlattenArrayOfArrays": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })), { "Type": null }),
+        "Push": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("PushParameters", { "Type": typeParameter("Type") })), { "Type": null }),
+
+
+        "MatchArrays": sfunction(
+            typeReference("MatchedArrays", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
+            data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
+            { "Benchmark": null, "Focus": null }
+        ),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/boolean/api.data.ts

@@ -0,0 +1,21 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "array_and": algorithm("Array And", null, {}),
+        "array_or": algorithm("Array Or", null, {}),
+        "array_xor": algorithm("Array Xor", null, {}),
+        "and": algorithm("And", null, {}),
+        "or": algorithm("Or", null, {}),
+        "xor": algorithm("Xor", null, {}),
+        "not": algorithm("Not", null, {}),
+    }
+)