pareto 0.57.0 → 0.59.0

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

@@ -1,51 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, afunction, boolean, computed, data, dictionary,
-    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
-    taggedUnion,
-    null_,
-    sInterface,
-    sInterfaceMethod
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Result": type(taggedUnion({
-                "success": ref(typeReference("JSONValue")),
-                "error": string(),
-            })),
-            //"Result": type(ref(glossaryParameter("Type"))),
-            "JSONValue": type(taggedUnion({
-                "object": dictionary(ref(typeReference("JSONValue"))),
-                "array": array(ref(typeReference("JSONValue"))),
-                "string": string(),
-                "number": number(),
-                "boolean": boolean(),
-                "null": null_(),
-            })),
-
-
-        }),
-    },
-    'interface types': d({
-
-    }),
-    'algorithm types': d({
-        "ConvertJSON": sfunction(typeReference("Result"), data(typeReference("String"))),
-
-        /*use this one if the application may crash if the JSON is invalid*/
-        "UnsafeConvertJSON": sfunction(typeReference("JSONValue"), data(typeReference("String"))),
-        //"Convert": sfunction(typeReference("Result"), data(typeReference("JSONValue"))),
-    }),
-}

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

@@ -1,15 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "flatten": algorithm("Flatten", null, {})
-    }
-)

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

@@ -1,29 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                "single": ref(typeParameter("Type")),
-                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type")}))),
-                "none": null_(),
-            })),
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Flatten": sfunction(typeReference("Array", { "Type": typeParameter("Type")}), data(typeReference("Nested", { "Type": typeParameter("Type")})), { "Type": null })
-    }),
-}

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

@@ -1,18 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "smallerThan": algorithm("SmallerThan", null, {}),
-        "greaterThan": algorithm("GreaterThan", null, {}),
-        "isZero": algorithm("IsZero", null, {}),
-        "equal": algorithm("Equal", null, {}),
-    }
-)

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

@@ -1,40 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
-    type, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "Number": type(number()),
-            "NumberPair": type(group({
-                "yin": member(number()),
-                "yang": member(number()),
-            })),
-            "CompareData": type(group({
-                "benchmark": member(number()),
-                "focus": member(number()),
-            })),
-
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "IsZero": sfunction(typeReference("Boolean"), data(typeReference("Number"))),
-
-        "GreaterThan": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
-        "SmallerThan": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
-        "Equal": sfunction(typeReference("Boolean"), data(typeReference("NumberPair"))),
-    }),
-}

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

@@ -1,19 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-
-        "convertWindowsPathToPosixPath": algorithm("ConvertWindowsPathToPosixPath", null, {}),
-        "basename": algorithm("Basename", null, {}),
-        "dirname": algorithm("Dirname", null, {}),
-        "parseFilePath": algorithm("ParseFilePath", null, {}),
-    }
-)

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

@@ -1,35 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, data, externalTypeReference, group, member, sfunction, string, type, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "ParseFilePathData": type(group({
-                "filePath": member(string()),
-                "pathSeparator": member(string()),
-            })),
-            "ParsedFilePath": type(group({
-                "directoryPath": member(array(string())),
-                "baseName": member(string()),
-            })),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "ConvertWindowsPathToPosixPath": sfunction(typeReference("String"), data(typeReference("String"))),
-        "Basename": sfunction(typeReference("String"), data(typeReference("String"))),
-        "Dirname": sfunction(typeReference("String"), data(typeReference("String"))),
-        "ParseFilePath": sfunction(typeReference("ParsedFilePath"), data(typeReference("ParseFilePathData"))),
-    }),
-}

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

@@ -1,20 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "sortTopologically": algorithm("SortTopologically", null, {}),
-        // "unsafeResolveDictionary": algorithm("UnsafeResolveDictionary", null, {}),
-        // "safeResolveDictionary": algorithm("SafeResolveDictionary", null, {
-        // }, {
-        //     "onError": sideEffect("OnError", 'sync')
-        // }),
-    }
-)

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

@@ -1,84 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    string, member, group,
-    typeReference,
-    data,
-    sfunction,
-    type,
-    externalTypeReference,
-    boolean,
-    parametrizedType,
-    dictionary,
-    ref,
-    typeParameter,
-    array,
-    null_,
-    computed,
-    sInterface,
-    sInterfaceMethod,
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters':d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "AnySibling": parametrizedType({ "Type": null }, computed(ref(typeParameter("Type")))),
-
-            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                "value": member(ref(typeParameter("Type"))),
-                "dependencies": member(dictionary(null_())),
-            }))),
-
-
-            "Error": type(string()),
-
-        }),
-    },
-    'interface types': d({
-        "OnError": sInterface(sInterfaceMethod(typeReference("Error"))),
-
-
-    }),
-    'algorithm types': d({
-        "SortTopologically": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        // "UnsafeResolveDictionary": scallbackfunction(
-        //     typeReference("Dictionary", { "Type": typeParameter("Out") }),
-        //     data(typeReference("Dictionary", { "Type": typeParameter("In") })),
-        //     {
-        //         "map": scallback(typeParameter("Out"), typeReference("KeyValuePair", { "Type": typeParameter("In") }), {
-        //             "non circular siblings": typeParameter("Out"),
-        //             "all siblings": typeReference("AnySibling", { "Type": typeParameter("Out") }),
-        //         })
-        //     },
-        //     { "In": null, "Out": null }
-        // ),
-        // "SafeResolveDictionary": scallbackfunction(
-        //     typeReference("Dictionary", { "Type": typeParameter("Out") }),
-        //     data(typeReference("Dictionary", { "Type": typeParameter("In") })),
-        //     {
-        //         "map": scallback(typeParameter("Out"), typeReference("KeyValuePair", { "Type": typeParameter("In") }), {
-        //             "non circular siblings": typeParameter("Out"),
-        //             "all siblings": typeReference("AnySibling", { "Type": typeParameter("Out") }),
-        //         })
-        //     },
-        //     { "In": null, "Out": null }
-        // ),
-    }),
-}

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

@@ -1,26 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-
-        "escape": algorithm("Escape", null, {}),
-        "fromCharacterArray": algorithm("FromCharacterArray", null, {}),
-        "join": algorithm("Join", null, {}),
-        "length": algorithm("Length", null, {}),
-        "replaceAll": algorithm("ReplaceAll", null, {}),
-        "split": algorithm("Split", null, {}),
-        "splitIn2": algorithm("SplitIn2", null, {}),
-        "startsWith": algorithm("StartsWith", null, {}),
-        "substr": algorithm("Substr", null, {}),
-        "toCharacterArray": algorithm("ToCharacterArray", null, {}),
-        "trimEnd": algorithm("TrimEnd", null, {}),
-    }
-)

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

@@ -1,75 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Length": type(number()),
-            "Boolean": type(boolean()),
-            "CharacterArray": type(array(number())),
-            "SplitData": type(group({
-                "value": member(string()),
-                "splitter": member(string()),
-            })),
-            "SplitIn2Result": type(group({
-                "head": member(string()),
-                "tail": member(optional(string())),
-            })),
-            "SplitResult": type(array(string())),
-            "StartsWithData": type(group({
-                "contextString": member(string()),
-                "searchString": member(string()),
-            })),
-            "SubstrData": type(group({
-                "value": member(string()),
-                "begin": member(number()),
-                "length": member(number()),
-            })),
-            "ReplaceAllData": type(group({
-                "value": member(string()),
-                "pattern": member(string()),
-                "replacement": member(string()),
-            })),
-            "JoinData": type(group({
-                "first": member(string()),
-                "second": member(string()),
-            })),
-
-            "EscapeParameters": type(group({
-                "string": member(string()),
-                "escape": member(string()),
-                "patterns to escape": member(array(string())),
-            }))
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Escape": sfunction(typeReference("String"), data(typeReference("EscapeParameters"))),
-
-        "ReplaceAll": sfunction(typeReference("String"), data(typeReference("ReplaceAllData"))),
-        "Substr": sfunction(typeReference("String"), data(typeReference("SubstrData"))),
-        "ToCharacterArray": sfunction(typeReference("CharacterArray"), data(typeReference("String"))),
-        "Join": sfunction(typeReference("String"), data(typeReference("JoinData"))),
-        "FromCharacterArray": sfunction(typeReference("String"), data(typeReference("CharacterArray"))),
-        "Split": sfunction(typeReference("SplitResult"), data(typeReference("SplitData"))),
-        "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
-        "Length": sfunction(typeReference("Length"), data(typeReference("String"))),
-        "TrimEnd": sfunction(typeReference("String"), data(typeReference("String"))),
-        "StartsWith": sfunction(typeReference("Boolean"), data(typeReference("StartsWithData"))),
-    }),
-}

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

@@ -1,19 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, member, type, group, string, optional, number } from 'pareto/auto.dist/public/shorthands/cosmos'
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
-        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
-        "getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
-
-        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
-
-    }
-)

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

@@ -1,42 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, data, dictionary, typeReference, group, member, null_, number, optional, sfunction, string, type,
-    parametrizedType,
-    ref,
-    typeParameter
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
-            "StringArray": type(array(string())),
-            "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
-
-
-            "Configuration": type(group({
-                "separator": member(string()),
-                "maximum": member(optional(group({
-                    "maximum": member(number()),
-                    "suffix": member(string()),
-                }))),
-            })),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "GetLengthAsString": sfunction(typeReference("String"), data(typeReference("Array", { "T": typeParameter("T") })), { "T": null}),
-        "GetArrayAsString": sfunction(typeReference("String"), data(typeReference("StringArray"))),
-        "GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
-        "GetNumberOfKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
-    }),
-}

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

@@ -1,15 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "serialize": algorithm("Serialize", null, {}),
-    }
-)

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

@@ -1,47 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    array, afunction, boolean, computed, data, dictionary,
-    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
-    taggedUnion,
-    null_,
-    sInterface,
-    sInterfaceMethod
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({}),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Result": type(taggedUnion({
-                "success": ref(typeReference("Value")),
-                "error": string(),
-            })),
-            //"Result": type(ref(glossaryParameter("Type"))),
-            "Value": type(taggedUnion({
-                "object": dictionary(ref(typeReference("Value"))),
-                "array": array(ref(typeReference("Value"))),
-                "string": string(),
-                "number": number(),
-                "boolean": boolean(),
-                "null": null_(),
-            })),
-
-
-        }),
-    },
-    'interface types': d({
-
-    }),
-    'algorithm types': d({
-        "Serialize": sfunction(typeReference("String"), data(typeReference("Value"))),
-    }),
-}

package/auto.pareto/auto.dependencies/res-typescript/$.data.ts

@@ -1,35 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_library from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-
-const d = pd.d
-
-import { } from "pareto/auto.dist/public/shorthands/cosmos"
-
-import { $ as d_serialize } from "./modules/serialize/api.data"
-import { $ as d_naming } from "./modules/naming/api.data"
-
-
-export const $: g_library.D.Library = {
-    'author': "Corno",
-    'description': "provides functionality to support javascript code generation. helps create valid identifiers, quoted strings etcetera",
-    'license': "TBD",
-
-    'type': ['impure', null],
-    'module sets': {
-        'public': {
-            'glossaries': d({}),
-            'modules': d({
-
-                "serialize": d_serialize,
-                "naming": d_naming,
-            }),
-        },
-        'private': {
-            'glossaries': d({}),
-            'modules': d({}),
-        },
-    }
-    // 'modules': d({
-    // }),
-}

package/auto.pareto/auto.dependencies/res-typescript/modules/naming/api.data.ts

@@ -1,15 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "createIdentifier": algorithm("CreateIdentifier", null, {}),
-    }
-)

package/auto.pareto/auto.dependencies/res-typescript/modules/naming/glossary.data.ts

@@ -1,34 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    data,
-    sfunction,
-    type,
-    group,
-    typeReference,
-    member,
-    string,
-    dictionary,
-    null_,
-    array,
-} from "pareto/auto.dist/public/shorthands/cosmos"
-
-import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-        }),
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "CreateIdentifier": sfunction(typeReference("String"), data(typeReference("String"))),
-    }),
-
-}

package/auto.pareto/auto.dependencies/res-typescript/modules/serialize/api.data.ts

@@ -1,18 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, api } from "pareto/auto.dist/public/shorthands/cosmos"
-
-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 'pareto/auto.dist/public/shorthands/cosmos'
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "escape": algorithm("Escape", null, {}),
-        "createQuotedString": algorithm("CreateQuotedString", null, {}),
-        "createApostrophedString": algorithm("CreateBacktickedString", null, {}),
-        "createBacktickedString": algorithm("CreateApostrophedString", null, {}),
-    }
-)