pareto 0.53.0 → 0.55.0

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

@@ -0,0 +1,50 @@
+import * as t from "../glossaries/cosmos__type__system";
+type RawDictionary<T> = {
+    [key: string]: T;
+};
+export declare function glossary(glossary_parameters: RawDictionary<t.D.Parameters.DX>, imports: RawDictionary<t.D.Glossary.imports.DX>, namespaces: RawDictionary<t.D.Namespace>, datatypes: RawDictionary<t.D.Namespace.data__types.DX>, interface_types: RawDictionary<t.D.Glossary.interface__types.DX>, algorithm_types: RawDictionary<t.D.Glossary.algorithm__types.DX>): t.D.Glossary;
+export declare function imp(glossary: t.D.Glossary, typeArgs: RawDictionary<t.D.Arguments.DX>): t.D.Glossary.imports.DX;
+export declare function null_(): t.D.Data__Type;
+export declare function boolean(): t.D.Data__Type;
+export declare function string(): t.D.Data__Type;
+export declare function number(): t.D.Data__Type;
+export declare function taggedUnion($: RawDictionary<t.D.Data__Type>): t.D.Data__Type;
+export declare function dictionary($: t.D.Data__Type): t.D.Data__Type;
+export declare function parametrizedType(parameters: RawDictionary<t.D.Parameters.DX>, type: t.D.Data__Type): t.D.Namespace.data__types.DX;
+export declare function ns(types: RawDictionary<t.D.Namespace.data__types.DX>, ns: RawDictionary<t.D.Namespace.namespaces.DX>): t.D.Namespace;
+export declare function type(type: t.D.Data__Type): t.D.Namespace.data__types.DX;
+export declare function typeParameter($: string): t.D.DataSpecifier;
+export declare function glossaryParameter($: string): t.D.DataSpecifier;
+export declare function array($: t.D.Data__Type): t.D.Data__Type;
+export declare function optional($: t.D.Data__Type): t.D.Data__Type;
+export declare function computed($: t.D.Data__Type): t.D.Data__Type;
+export declare function group($: RawDictionary<t.D.Data__Type.group.DX>): t.D.Data__Type;
+export declare function member($: t.D.Data__Type): t.D.Data__Type.group.DX;
+export declare function ref(typeReference: t.D.DataSpecifier): t.D.Data__Type;
+export declare function externalTypeReference(contextX: string, type: string, typeArgs?: RawDictionary<t.D.DataSpecifier>): t.D.DataSpecifier;
+export declare function typeReference(type: string, typeArgs?: RawDictionary<t.D.DataSpecifier>): t.D.DataSpecifier;
+export declare function sExternalInterfaceReference(contextX: string, inf: string, glossArgs?: RawDictionary<t.D.DataSpecifier>, typeArgs?: RawDictionary<t.D.DataSpecifier>): t.D.Synchronous__Interface__Reference;
+export declare function sInterfaceReference(inf: string, args?: RawDictionary<t.D.DataSpecifier>): t.D.Synchronous__Interface__Reference;
+export declare function aExternalInterfaceReference(contextX: string, inf: string, glossArgs?: RawDictionary<t.D.DataSpecifier>, typeArgs?: RawDictionary<t.D.DataSpecifier>): t.D.Asynchronous__Interface__Reference;
+export declare function aInterfaceReference(inf: string, args?: RawDictionary<t.D.DataSpecifier>): t.D.Asynchronous__Interface__Reference;
+export declare function data($: t.D.DataSpecifier): t.D.Data__Or__Synchronous__Interface;
+export declare function sInf($: t.D.Synchronous__Interface__Reference): t.D.Data__Or__Synchronous__Interface;
+export declare function aInterface(inf: t.D.Asynchronous__Interface__Type, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.interface__types.DX;
+export declare function sInterface(inf: t.D.Synchronous__Interface__Type, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.interface__types.DX;
+export declare function infInit(inf: t.D.Asynchronous__Interface__Reference, downstreams: RawDictionary<t.D.Asynchronous__Interface__Reference>, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.algorithm__types.DX;
+export declare function resource(request: t.D.DataSpecifier, consumer: t.D.Asynchronous__Interface__Reference, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.algorithm__types.DX;
+export declare function afunction(out: t.D.Glossary.algorithm__types.DX._ltype.asynchronous__function.out, in_: t.D.Glossary.algorithm__types.DX._ltype.asynchronous__function._lin, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.algorithm__types.DX;
+export declare function procedure(in_: t.D.Data__Or__Synchronous__Interface, out: t.D.Synchronous__Interface__Reference, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.algorithm__types.DX;
+export declare function sfunction(out: t.D.DataSpecifier, in_: t.D.Data__Or__Synchronous__Interface, params?: RawDictionary<t.D.Parameters.DX>): t.D.Glossary.algorithm__types.DX;
+export declare function sInterfaceMethod(data: null | t.D.DataSpecifier, inf?: null | t.D.Synchronous__Interface__Type): t.D.Synchronous__Interface__Type;
+export declare function aInterfaceMethod(data: null | t.D.DataSpecifier, inf?: null | t.D.Asynchronous__Interface__Type): t.D.Asynchronous__Interface__Type;
+export declare function infref($: t.D.Asynchronous__Interface__Reference): t.D.Asynchronous__Interface__Type;
+export declare function choice(options: RawDictionary<t.D.Asynchronous__Interface__Type>): t.D.Asynchronous__Interface__Type;
+export declare function streamconsumer(data: t.D.Asynchronous__Interface__Type, end: null | t.D.Asynchronous__Interface__Type): t.D.Asynchronous__Interface__Type;
+export declare function api(prov_glo: t.D.Glossary, algs: RawDictionary<t.D.API.algorithms.DX>): t.D.API;
+export declare function algref(definition: string): t.D.Algorithm__Type__Reference;
+export declare function sibling(module: string, alg: string, args: RawDictionary<t.D.API.algorithms.DX.dependencies.DX.type__arguments.DX>): t.D.API.algorithms.DX.dependencies.DX;
+export declare function libDep(lib: string, module: string, alg: string, args: RawDictionary<t.D.API.algorithms.DX.dependencies.DX.type__arguments.DX>): t.D.API.algorithms.DX.dependencies.DX;
+export declare function private_(module: string, alg: string, args: RawDictionary<t.D.API.algorithms.DX.dependencies.DX.type__arguments.DX>): t.D.API.algorithms.DX.dependencies.DX;
+export declare function algorithm(def: string, data: null | string, deps: RawDictionary<t.D.API.algorithms.DX.dependencies.DX>): t.D.API.algorithms.DX;
+export {};

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

@@ -0,0 +1,512 @@
+"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.glossary = glossary;
+exports.imp = imp;
+exports.null_ = null_;
+exports.boolean = boolean;
+exports.string = string;
+exports.number = number;
+exports.taggedUnion = taggedUnion;
+exports.dictionary = dictionary;
+exports.parametrizedType = parametrizedType;
+exports.ns = ns;
+exports.type = type;
+exports.typeParameter = typeParameter;
+exports.glossaryParameter = glossaryParameter;
+exports.array = array;
+exports.optional = optional;
+exports.computed = computed;
+exports.group = group;
+exports.member = member;
+exports.ref = ref;
+exports.externalTypeReference = externalTypeReference;
+exports.typeReference = typeReference;
+exports.sExternalInterfaceReference = sExternalInterfaceReference;
+exports.sInterfaceReference = sInterfaceReference;
+exports.aExternalInterfaceReference = aExternalInterfaceReference;
+exports.aInterfaceReference = aInterfaceReference;
+exports.data = data;
+exports.sInf = sInf;
+exports.aInterface = aInterface;
+exports.sInterface = sInterface;
+exports.infInit = infInit;
+exports.resource = resource;
+exports.afunction = afunction;
+exports.procedure = procedure;
+exports.sfunction = sfunction;
+exports.sInterfaceMethod = sInterfaceMethod;
+exports.aInterfaceMethod = aInterfaceMethod;
+exports.infref = infref;
+exports.choice = choice;
+exports.streamconsumer = streamconsumer;
+exports.api = api;
+exports.algref = algref;
+exports.sibling = sibling;
+exports.libDep = libDep;
+exports.private_ = private_;
+exports.algorithm = algorithm;
+const pd = __importStar(require("pareto-core-data"));
+const d = pd.d;
+function glossary(glossary_parameters, imports, namespaces, datatypes, interface_types, algorithm_types) {
+    return {
+        'glossary parameters': pd.d(glossary_parameters),
+        'imports': pd.d(imports),
+        'root': {
+            'namespaces': pd.d(namespaces),
+            'data types': pd.d(datatypes),
+        },
+        'interface types': pd.d(interface_types),
+        'algorithm types': pd.d(algorithm_types),
+    };
+}
+function imp(glossary, typeArgs) {
+    return {
+        'glossary': glossary,
+        'type arguments': pd.d(typeArgs)
+    };
+}
+function null_() {
+    return ['null', null];
+}
+function boolean() {
+    return ['boolean', null];
+}
+function string() {
+    return ['string', null];
+}
+function number() {
+    return ['number', null];
+}
+function taggedUnion($) {
+    return ['taggedUnion', pd.d($)];
+}
+function dictionary($) {
+    return ['dictionary', $];
+}
+function parametrizedType(parameters, type) {
+    return {
+        'parameters': pd.d(parameters),
+        'type': type,
+    };
+}
+function ns(types, ns) {
+    return {
+        'namespaces': pd.d(ns),
+        'data types': pd.d(types),
+    };
+}
+function type(type) {
+    return {
+        'parameters': pd.d({}),
+        'type': type,
+    };
+}
+function typeParameter($) {
+    return ['type parameterXX', $];
+}
+function glossaryParameter($) {
+    return ['glossary parameterXX', $];
+}
+function array($) {
+    return ['array', $];
+}
+function optional($) {
+    return ['optional', $];
+}
+function computed($) {
+    return ['computed', $];
+}
+function group($) {
+    return ['group', pd.d($)];
+}
+function member($) {
+    return {
+        type: $
+    };
+}
+function ref(typeReference) {
+    return ['reference', typeReference];
+}
+// export function context(glossary: string, annotation: pd.SourceLocation): t.D.Context {
+//     if (glossary === undefined) {
+//         return ['local', null]
+//     } else {
+//         return ['import', {
+//             // 'glossary': {
+//             //     'annotation': annotation,
+//             //     'key': glossary,
+//             // },
+//             'glossaryXX': glossary,
+//         }]
+//     }
+// }
+// export function imp(): t.D.Imports.DX {
+//     return null
+// }
+function externalTypeReference(contextX, type, 
+//glossArgs?: RawDictionary<t.D.DataSpecifier>,
+typeArgs) {
+    return ['type', {
+            'context': ['import', {
+                    // 'glossary': {
+                    //     'annotation': annotation,
+                    //     'key': glossary,
+                    // },
+                    'glossary': {
+                        'glossary': contextX,
+                        // 'glossary': {
+                        //     'annotation': pd.getLocationInfo(1),
+                        //     'key': contextX,
+                        // },
+                        //'glossary arguments': pd.d(glossArgs === undefined ? {} : glossArgs),
+                    },
+                }],
+            'typeXX': type,
+            'tailXX': pd.a([]),
+            'type arguments': pd.d(typeArgs === undefined ? {} : typeArgs),
+        }];
+}
+function typeReference(type, typeArgs) {
+    return ['type', {
+            'context': ['local', null],
+            'typeXX': type,
+            'tailXX': pd.a([]),
+            'type arguments': pd.d(typeArgs === undefined ? {} : typeArgs),
+        }];
+}
+function sExternalInterfaceReference(contextX, inf, glossArgs, typeArgs) {
+    return {
+        'context': ['import', {
+                // 'glossary': {
+                //     'annotation': annotation,
+                //     'key': glossary,
+                // },
+                'glossary': {
+                    'glossary': contextX,
+                    // 'glossary': {
+                    //     'annotation': pd.getLocationInfo(1),
+                    //     'key': contextX,
+                    // },
+                    //'glossary arguments': pd.d(glossArgs === undefined ? {} : glossArgs),
+                },
+                // 'interface FIXME': {
+                //     'annotation': pd.getLocationInfo(1),
+                //     'key': inf,
+                // },
+                'interfaceXX': inf
+            }],
+        'type arguments': pd.d(typeArgs === undefined ? {} : typeArgs),
+    };
+}
+function sInterfaceReference(inf, args) {
+    return {
+        'context': ['local', {
+                // 'interface': {
+                //     'annotation': pd.getLocationInfo(1),
+                //     'key': inf,
+                // },
+                'interfaceXX': inf
+            }],
+        'type arguments': pd.d(args === undefined ? {} : args),
+    };
+}
+function aExternalInterfaceReference(contextX, inf, glossArgs, typeArgs) {
+    return {
+        'context': ['import', {
+                // 'glossary': {
+                //     'annotation': annotation,
+                //     'key': glossary,
+                // },
+                'glossary': {
+                    'glossary': contextX,
+                    // 'glossary': {
+                    //     'annotation': pd.getLocationInfo(1),
+                    //     'key': contextX,
+                    // },
+                    //'glossary arguments': pd.d(glossArgs === undefined ? {} : glossArgs),
+                },
+            }],
+        'interfaceXX': inf,
+        'type arguments': pd.d(typeArgs === undefined ? {} : typeArgs),
+    };
+}
+function aInterfaceReference(inf, args) {
+    return {
+        'context': ['local', null],
+        'interfaceXX': inf,
+        'type arguments': pd.d(args === undefined ? {} : args),
+    };
+}
+// export function nothing(): ['nothing', null] {
+//     return ['nothing', null]
+// }
+function data($) {
+    return ['data', $];
+}
+function sInf($) {
+    return ['interface', $];
+}
+// export function aInf($: t.D.Asynchronous__Interface__Reference): ['interface', t.D.Asynchronous__Interface__Reference] {
+//     return ['interface', $]
+// }
+function aInterface(inf, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['asynchronous', {
+                'interface': inf,
+            }]
+    };
+}
+function sInterface(inf, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['synchronous', {
+                'interface': inf,
+            }]
+    };
+}
+function infInit(inf, downstreams, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['interface initializer', {
+                'interface': inf,
+                'downstreams': pd.d(downstreams),
+            }]
+    };
+}
+function resource(request, consumer, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['resource initializer', {
+                'request': request,
+                'consumer': consumer,
+            }]
+    };
+}
+function afunction(out, in_, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['asynchronous function', {
+                'in': in_,
+                'out': out,
+            }]
+    };
+}
+function procedure(in_, out, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['procedure', {
+                'in': in_,
+                'out': out,
+            }]
+    };
+}
+function sfunction(out, in_, params) {
+    return {
+        'parameters': pd.d(params === undefined ? {} : params),
+        'type': ['synchronous function', {
+                'in': in_,
+                'out': out,
+            }]
+    };
+}
+function sInterfaceMethod(data, inf) {
+    return ['method', {
+            'data': data === null
+                ? pd.notSet()
+                : pd.set(data),
+            'interface': inf === undefined
+                ? pd.notSet()
+                : inf === null
+                    ? pd.notSet()
+                    : pd.set(inf),
+        }];
+}
+function aInterfaceMethod(data, inf) {
+    return ['method', {
+            'data': data === null
+                ? pd.notSet()
+                : pd.set(data),
+            'interface': inf === undefined
+                ? pd.notSet()
+                : inf === null
+                    ? pd.notSet()
+                    : pd.set(inf),
+        }];
+}
+function infref($) {
+    return ['reference', $];
+}
+function choice(options) {
+    return ['choice', {
+            'options': pd.d(options),
+        }];
+}
+function streamconsumer(data, end) {
+    return ['streamconsumer', {
+            'data': data,
+            'end': end === null ? pd.notSet() : pd.set(end)
+        }];
+}
+// export function module(
+//     acc: "public" | "private",
+//     api: g_this.D.API,
+// ): g_this.D.Library.modules.DX {
+//     return {
+//         'accessibility': acc === "public" ? ['public', null] : ['private', null],
+//         'api': api,
+//     }
+// }
+function api(prov_glo, algs) {
+    return {
+        'provided interface': prov_glo,
+        'algorithms': d(algs)
+    };
+}
+// export function libDep(
+//     name: string,
+//     glos: string,
+//     targs: RawDictionary<t.D.API.dependencies.DX.type__arguments.DX>
+// ): t.D.API.dependencies.DX {
+//     return {
+//         'type': [ 'library dependency', name],
+//         'glossary': glos,
+//         'type arguments': d(targs),
+//     }
+// }
+// export function sibling(
+//     glos: string,
+//     targs: RawDictionary<t.D.API.dependencies.DX.type__arguments.DX>
+// ): t.D.API.dependencies.DX {
+//     return {
+//         'type': [ 'sibling', null],
+//         'glossary': glos,
+//         'type arguments': d(targs),
+//     }
+// }
+// export function pub(
+//     glos: string,
+//     targs: RawDictionary<t.D.API.dependencies.DX.type__arguments.DX>
+// ): t.D.API.dependencies.DX {
+//     return {
+//         'type': [ 'public', null],
+//         'glossary': glos,
+//         'type arguments': d(targs),
+//     }
+// }
+// export function sideEffect(inf: string, type: 'async' | 'sync'): t.D.API.algorithms.DX.side__effects.DX {
+//     return {
+//         'interface': inf,
+//         'type': type === 'async' ? ['asynchronous', null] : ['synchronous', null]
+//     }
+// }
+function algref(definition) {
+    return {
+        // '': {
+        //     'glossary': context,
+        //     'arguments': pd.d(args === undefined ? {} : args)
+        // },
+        'algorithm type': definition,
+        // 'type': pl.cc(type, ($) => {
+        //     switch ($) {
+        //         case 'interface': return ['interface initializer', null]
+        //         case 'procedure': return ['procedure', null]
+        //         case 'resource': return ['resource initializer', null]
+        //         case 'sync func': return ['synchronous function', null]
+        //         case 'async func': return ['asynchronous function', null]
+        //         default: return pl.au($[0])
+        //     }
+        // })
+    };
+}
+function sibling(module, alg, args) {
+    return {
+        'type': ['sibling', null],
+        'module': module,
+        'type arguments': d(args),
+        'algorithm type': {
+            'algorithm type': alg
+        },
+    };
+}
+function libDep(lib, module, alg, args) {
+    return {
+        'type': ['library dependency', lib],
+        'module': module,
+        'type arguments': d(args),
+        'algorithm type': {
+            'algorithm type': alg
+        },
+    };
+}
+function private_(module, alg, args) {
+    return {
+        'type': ['private', null],
+        'module': module,
+        'type arguments': d(args),
+        'algorithm type': {
+            'algorithm type': alg
+        },
+    };
+}
+// export function dependency(glos: string, alg: string): t.D.API.algorithms.DX.dependencies.DX {
+//     return {
+//         'type': ['library dependency', "SDFSF"],
+//         'glossary': glos,
+//         'type arguments': d({}),
+//         'algorithm type': {
+//             'algorithm type': alg
+//         },
+//     }
+// }
+function algorithm(def, data, deps) {
+    return {
+        'definition': {
+            'algorithm type': def,
+        },
+        'configuration data': data === null
+            ? pd.notSet()
+            : pd.set(data),
+        'dependencies': pd.d(deps),
+    };
+}
+// export function executable(module: string, initializer: string): g_this.D.Library.executables.DX {
+//     return {
+//         'module': module,
+//         'initializer': initializer,
+//     }
+// }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cosmos.js","sourceRoot":"","sources":["../../../src/public/shorthands/cosmos.ts"],"names":[],"mappings":"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"}

package/auto.pareto/$.data.ts

@@ -1,10 +1,10 @@
 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"
+import * as g_project from "lib-pareto-typescript-project/dist/modules/cosmos_type_system"
 
 const d = pd.d
-import { } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+import { } from "lib-pareto-typescript-project/dist/modules/cosmos_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"

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

@@ -4,6 +4,6 @@ import { $ as dep_pareto_standard_impure_library } from './pareto-standard-impur
 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' },
+    'pareto-standard-impure-library': { library: dep_pareto_standard_impure_library, version: '^0.10.0' },
+    'res-typescript': { library: dep_res_typescript, version: '^0.36.0' },
 })

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

@@ -1,9 +1,9 @@
 import * as pd from 'pareto-core-data'
 
-import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 
 const d = pd.d
-import { } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+import { } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
 
 import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
 import { $ as d_array } from "./modules/array/api.data"
@@ -22,7 +22,7 @@ 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> = {
+export const $: g_project.D.Library = {
     'author': "Corno",
     'description': "A library that contains very common functionality that cannot be implemented purely in Pareto",
     'license': "TBD",

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

@@ -1,13 +1,13 @@
 import * as pd from 'pareto-core-data'
 
-import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
 
-import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__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'
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands'
 
-export const $: g_project.D.API<pd.SourceLocation> = api(
+export const $: g_project.D.API = api(
     glos,
     {
         "arrayMax": algorithm("ArrayMax", null, {}),

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

@@ -3,13 +3,13 @@ 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"
+} from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
 
-import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 
 const d = pd.d
 
-export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+export const $: g_glossary.D.Glossary = {
     'glossary parameters': d({}),
     'imports': d({
     }),