@ng-org/shex-orm 0.1.2

package/dist/schema-converter/transformers/ShexJSchemaTransformer.js

@@ -0,0 +1,239 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+import ShexJTraverser from "@ldo/traverser-shexj";
+const rdfDataTypeToBasic = (dataType) => {
+    switch (dataType) {
+        case "http://www.w3.org/2001/XMLSchema#string":
+        case "http://www.w3.org/2001/XMLSchema#ENTITIES":
+        case "http://www.w3.org/2001/XMLSchema#ENTITY":
+        case "http://www.w3.org/2001/XMLSchema#ID":
+        case "http://www.w3.org/2001/XMLSchema#IDREF":
+        case "http://www.w3.org/2001/XMLSchema#IDREFS":
+        case "http://www.w3.org/2001/XMLSchema#language":
+        case "http://www.w3.org/2001/XMLSchema#Name":
+        case "http://www.w3.org/2001/XMLSchema#NCName":
+        case "http://www.w3.org/2001/XMLSchema#NMTOKEN":
+        case "http://www.w3.org/2001/XMLSchema#NMTOKENS":
+        case "http://www.w3.org/2001/XMLSchema#normalizedString":
+        case "http://www.w3.org/2001/XMLSchema#QName":
+        case "http://www.w3.org/2001/XMLSchema#token":
+            return "string";
+        case "http://www.w3.org/2001/XMLSchema#date":
+        case "http://www.w3.org/2001/XMLSchema#dateTime":
+        case "http://www.w3.org/2001/XMLSchema#duration":
+        case "http://www.w3.org/2001/XMLSchema#gDay":
+        case "http://www.w3.org/2001/XMLSchema#gMonth":
+        case "http://www.w3.org/2001/XMLSchema#gMonthDay":
+        case "http://www.w3.org/2001/XMLSchema#gYear":
+        case "http://www.w3.org/2001/XMLSchema#gYearMonth":
+        case "http://www.w3.org/2001/XMLSchema#time":
+            return "string";
+        case "http://www.w3.org/2001/XMLSchema#byte":
+        case "http://www.w3.org/2001/XMLSchema#decimal":
+        case "http://www.w3.org/2001/XMLSchema#double":
+        case "http://www.w3.org/2001/XMLSchema#float":
+        case "http://www.w3.org/2001/XMLSchema#int":
+        case "http://www.w3.org/2001/XMLSchema#integer":
+        case "http://www.w3.org/2001/XMLSchema#long":
+        case "http://www.w3.org/2001/XMLSchema#negativeInteger":
+        case "http://www.w3.org/2001/XMLSchema#nonNegativeInteger":
+        case "http://www.w3.org/2001/XMLSchema#nonPositiveInteger":
+        case "http://www.w3.org/2001/XMLSchema#positiveInteger":
+        case "http://www.w3.org/2001/XMLSchema#short":
+        case "http://www.w3.org/2001/XMLSchema#unsignedLong":
+        case "http://www.w3.org/2001/XMLSchema#unsignedInt":
+        case "http://www.w3.org/2001/XMLSchema#unsignedShort":
+        case "http://www.w3.org/2001/XMLSchema#unsignedByte":
+            return "number";
+        case "http://www.w3.org/2001/XMLSchema#boolean":
+            return "boolean";
+        case "http://www.w3.org/2001/XMLSchema#hexBinary":
+            return "string";
+        case "http://www.w3.org/2001/XMLSchema#anyURI":
+            return "iri";
+        default:
+            return "string";
+    }
+};
+export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
+    Schema: {
+        transformer: async (_schema, getTransformedChildren) => {
+            const transformedChildren = await getTransformedChildren();
+            return transformedChildren.shapes || [];
+        },
+    },
+    ShapeDecl: {
+        transformer: async (shapeDecl, getTransformedChildren) => {
+            const schema = await getTransformedChildren();
+            const shape = schema.shapeExpr;
+            return { ...shape, iri: shapeDecl.id };
+        },
+    },
+    Shape: {
+        transformer: async (_shape, getTransformedChildren) => {
+            // TODO: We don't handles those
+            _shape.closed;
+            const transformedChildren = await getTransformedChildren();
+            const compactShape = transformedChildren.expression;
+            for (const extra of _shape.extra || []) {
+                const extraPredicate = compactShape.predicates.find((p) => p.iri === extra);
+                if (extraPredicate)
+                    extraPredicate.extra = true;
+            }
+            return compactShape;
+        },
+    },
+    // EachOf contains the `expressions` array of properties (TripleConstraint)
+    EachOf: {
+        transformer: async (eachOf, getTransformedChildren) => {
+            const transformedChildren = await getTransformedChildren();
+            return {
+                iri: "",
+                predicates: transformedChildren.expressions.map(
+                // We disregard cases where properties are referenced (strings)
+                // or where they consist of Unions or Intersections (not supported).
+                (expr) => expr),
+            };
+        },
+    },
+    TripleConstraint: {
+        transformer: async (tripleConstraint, getTransformedChildren, _setReturnPointer) => {
+            const transformedChildren = await getTransformedChildren();
+            const commonProperties = {
+                maxCardinality: tripleConstraint.max ?? 1,
+                minCardinality: tripleConstraint.min ?? 1,
+                iri: tripleConstraint.predicate,
+                // @ts-expect-error The ldo library does not have our modded readablePredicate property.
+                readablePredicate: tripleConstraint.readablePredicate,
+            };
+            // Make property based on object type which is either a parsed schema, literal or type.
+            if (typeof transformedChildren.valueExpr === "string") {
+                // Reference to nested object
+                return {
+                    dataTypes: [
+                        {
+                            valType: "shape",
+                            shape: transformedChildren.valueExpr,
+                        },
+                    ],
+                    ...commonProperties,
+                };
+            }
+            else if (transformedChildren.valueExpr &&
+                transformedChildren.valueExpr.predicates) {
+                // Nested object
+                return {
+                    dataTypes: [
+                        {
+                            valType: "shape",
+                            shape: transformedChildren.valueExpr,
+                        },
+                    ],
+                    ...commonProperties,
+                };
+            }
+            else if (Array.isArray(transformedChildren.valueExpr)) {
+                return {
+                    dataTypes: transformedChildren.valueExpr, // DataType[]
+                    ...commonProperties,
+                };
+            }
+            else {
+                // type or literal
+                const nodeConstraint = transformedChildren.valueExpr;
+                return {
+                    dataTypes: [
+                        {
+                            valType: nodeConstraint.valType,
+                            literals: nodeConstraint.literals,
+                        },
+                    ],
+                    ...commonProperties,
+                };
+            }
+        },
+    },
+    NodeConstraint: {
+        transformer: async (nodeConstraint) => {
+            if (nodeConstraint.datatype) {
+                return {
+                    valType: rdfDataTypeToBasic(nodeConstraint.datatype),
+                };
+            }
+            if (nodeConstraint.nodeKind) {
+                // Something reference-like.
+                return { valType: "iri" };
+            }
+            if (nodeConstraint.values) {
+                return {
+                    valType: "literal",
+                    literals: nodeConstraint.values.map(
+                    // TODO: We do not convert them to number or boolean or lang tag.
+                    // And we don't have an annotation of the literal's type.
+                    (valueRecord) => {
+                        // If valueRecord is a string (IRIREF), return it directly
+                        if (typeof valueRecord === "string") {
+                            return valueRecord;
+                        }
+                        // Handle ObjectLiteral (has .value property)
+                        if ("value" in valueRecord) {
+                            return valueRecord.value;
+                        }
+                        // Handle other types with .id property (if any)
+                        if ("id" in valueRecord) {
+                            return valueRecord.id;
+                        }
+                        // Handle Language type (has .languageTag)
+                        if ("languageTag" in valueRecord) {
+                            return valueRecord.languageTag;
+                        }
+                        // Handle stem-based types (IriStem, LiteralStem, LanguageStem)
+                        if ("stem" in valueRecord) {
+                            return valueRecord.stem;
+                        }
+                        // Fallback - should not happen in well-formed ShEx
+                        return undefined;
+                    }),
+                };
+            }
+            // Maybe we should throw instead...
+            throw {
+                error: new Error("Could not parse Node Constraint"),
+                nodeConstraint,
+            };
+        },
+    },
+    // Transformer from ShapeOr
+    ShapeOr: {
+        transformer: async (shapeOr, getTransformedChildren) => {
+            const { shapeExprs } = await getTransformedChildren();
+            // Either a shape IRI, a nested shape or a node CompactSchemaValue (node constraint).
+            return (Array.isArray(shapeExprs) ? shapeExprs : [shapeExprs]);
+        },
+    },
+    // Transformer from ShapeAnd
+    ShapeAnd: {
+        transformer: async () => {
+            throw new Error("ShapeAnd not supported (compact)");
+        },
+    },
+    // Transformer from ShapeNot - not supported.
+    ShapeNot: {
+        transformer: async () => {
+            throw new Error("ShapeNot not supported (compact)");
+        },
+    },
+    // Transformer from ShapeExternal - not supported.
+    ShapeExternal: {
+        transformer: async () => {
+            throw new Error("ShapeExternal not supported (compact)");
+        },
+    },
+});

package/dist/schema-converter/transformers/ShexJTypingTransformer.d.ts

@@ -0,0 +1,366 @@
+import type { Annotation } from "shexj";
+import * as dom from "dts-dom";
+import type { InterfaceDeclaration } from "dts-dom";
+export interface ShapeInterfaceDeclaration extends InterfaceDeclaration {
+    shapeId?: string;
+}
+export declare const additionalCompactEnumAliases: Set<string>;
+export interface CompactTransformerContext {
+    getNameFromIri: (iri: string, rdfType?: string) => string;
+}
+export declare function toCamelCase(text: string): string;
+/**
+ * Name functions
+ */
+export declare function iriToName(iri: string): string;
+export declare function nameFromAnnotationOrId(obj: {
+    id?: string;
+    annotations?: Annotation[];
+}): string | undefined;
+export declare const ShexJTypingTransformerCompact: import("@ldo/type-traverser").Transformer<{
+    Schema: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Schema;
+        properties: {
+            startActs: "SemAct";
+            start: "shapeExprOrRef";
+            imports: "IRIREF";
+            shapes: "ShapeDecl";
+        };
+    };
+    ShapeDecl: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeDecl;
+        properties: {
+            id: "shapeDeclLabel";
+            abstract: "BOOL";
+            restricts: "shapeExprOrRef";
+            shapeExpr: "shapeExpr";
+        };
+    };
+    shapeExpr: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeExpr;
+        typeNames: "ShapeOr" | "ShapeAnd" | "ShapeNot" | "NodeConstraint" | "Shape" | "ShapeExternal";
+    };
+    shapeExprOrRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeExprOrRef;
+        typeNames: "shapeExpr" | "shapeDeclRef";
+    };
+    ShapeOr: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeOr;
+        properties: {
+            shapeExprs: "shapeExprOrRef";
+        };
+    };
+    ShapeAnd: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeAnd;
+        properties: {
+            shapeExprs: "shapeExprOrRef";
+        };
+    };
+    ShapeNot: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeNot;
+        properties: {
+            shapeExpr: "shapeExprOrRef";
+        };
+    };
+    ShapeExternal: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeExternal;
+        properties: Record<string, never>;
+    };
+    shapeDeclRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeDeclRef;
+        typeNames: "shapeDeclLabel" | "ShapeDecl";
+    };
+    shapeDeclLabel: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeDeclLabel;
+        typeNames: "IRIREF" | "BNODE";
+    };
+    NodeConstraint: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").NodeConstraint;
+        properties: {
+            datatype: "IRIREF";
+            values: "valueSetValue";
+            length: "INTEGER";
+            minlength: "INTEGER";
+            maxlength: "INTEGER";
+            pattern: "STRING";
+            flags: "STRING";
+            mininclusive: "numericLiteral";
+            minexclusive: "numericLiteral";
+            totaldigits: "INTEGER";
+            fractiondigits: "INTEGER";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    numericLiteral: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").numericLiteral;
+        typeNames: "INTEGER" | "DECIMAL" | "DOUBLE";
+    };
+    valueSetValue: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").valueSetValue;
+        typeNames: "objectValue" | "IriStem" | "IriStemRange" | "LiteralStem" | "LiteralStemRange" | "Language" | "LanguageStem" | "LanguageStemRange";
+    };
+    objectValue: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").objectValue;
+        typeNames: "IRIREF" | "ObjectLiteral";
+    };
+    ObjectLiteral: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ObjectLiteral;
+        properties: {
+            value: "STRING";
+            language: "STRING";
+            type: "STRING";
+        };
+    };
+    IriStem: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").IriStem;
+        properties: {
+            stem: "IRIREF";
+        };
+    };
+    IriStemRange: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").IriStemRange;
+        properties: {
+            stem: "IRIREF";
+            exclusions: "IriStemRangeExclusions";
+        };
+    };
+    IriStemRangeExclusions: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").IRIREF | import("@ldo/traverser-shexj").IriStem;
+        typeNames: "IRIREF" | "IriStem";
+    };
+    LiteralStem: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LiteralStem;
+        properties: {
+            stem: "STRING";
+        };
+    };
+    LiteralStemRange: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LiteralStemRange;
+        properties: {
+            stem: "LiteralStemRangeStem";
+            exclusions: "LiteralStemRangeExclusions";
+        };
+    };
+    LiteralStemRangeStem: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").STRING | import("@ldo/traverser-shexj").Wildcard;
+        typeNames: "STRING" | "Wildcard";
+    };
+    LiteralStemRangeExclusions: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").STRING | import("@ldo/traverser-shexj").LiteralStem;
+        typeNames: "STRING" | "LiteralStem";
+    };
+    Language: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Language;
+        properties: {
+            languageTag: "LANGTAG";
+        };
+    };
+    LanguageStem: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LanguageStem;
+        properties: {
+            stem: "LANGTAG";
+        };
+    };
+    LanguageStemRange: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LanguageStemRange;
+        properties: {
+            stem: "LanguageStemRangeStem";
+            exclusions: "LanguageStemRangeExclusions";
+        };
+    };
+    LanguageStemRangeStem: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").LANGTAG | import("@ldo/traverser-shexj").Wildcard;
+        typeNames: "LANGTAG" | "Wildcard";
+    };
+    LanguageStemRangeExclusions: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").LANGTAG | import("@ldo/traverser-shexj").LanguageStem;
+        typeNames: "LANGTAG" | "LanguageStem";
+    };
+    Wildcard: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Wildcard;
+        properties: Record<string, never>;
+    };
+    Shape: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Shape;
+        properties: {
+            closed: "BOOL";
+            extra: "IRIREF";
+            extends: "shapeExprOrRef";
+            expression: "tripleExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    tripleExpr: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExpr;
+        typeNames: "EachOf" | "OneOf" | "TripleConstraint";
+    };
+    tripleExprOrRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExprOrRef;
+        typeNames: "tripleExpr" | "tripleExprRef";
+    };
+    EachOf: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").EachOf;
+        properties: {
+            id: "tripleExprLabel";
+            min: "INTEGER";
+            max: "INTEGER";
+            expressions: "tripleExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    OneOf: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").OneOf;
+        properties: {
+            id: "tripleExprLabel";
+            min: "INTEGER";
+            max: "INTEGER";
+            expressions: "tripleExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    TripleConstraint: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").TripleConstraint;
+        properties: {
+            id: "tripleExprLabel";
+            min: "INTEGER";
+            max: "INTEGER";
+            inverse: "BOOL";
+            predicate: "IRIREF";
+            valueExpr: "shapeExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    tripleExprRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExprRef;
+        typeNames: "tripleExprLabel";
+    };
+    tripleExprLabel: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExprLabel;
+        typeNames: "IRIREF" | "BNODE";
+    };
+    SemAct: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").SemAct;
+        properties: {
+            name: "IRIREF";
+            code: "STRING";
+        };
+    };
+    Annotation: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Annotation;
+        properties: {
+            predicate: "IRI";
+            object: "objectValue";
+        };
+    };
+    IRIREF: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").IRIREF;
+    };
+    BNODE: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").BNODE;
+    };
+    INTEGER: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").INTEGER;
+    };
+    STRING: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").STRING;
+    };
+    DECIMAL: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").DECIMAL;
+    };
+    DOUBLE: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").DOUBLE;
+    };
+    LANGTAG: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").LANGTAG;
+    };
+    BOOL: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").BOOL;
+    };
+    IRI: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").IRI;
+    };
+}, {
+    Schema: {
+        return: dom.TopLevelDeclaration[];
+    };
+    ShapeDecl: {
+        return: dom.InterfaceDeclaration;
+    };
+    Shape: {
+        return: dom.InterfaceDeclaration;
+    };
+    EachOf: {
+        return: dom.ObjectType | dom.InterfaceDeclaration;
+    };
+    TripleConstraint: {
+        return: dom.PropertyDeclaration;
+    };
+    NodeConstraint: {
+        return: dom.Type;
+    };
+    ShapeOr: {
+        return: dom.UnionType;
+    };
+    ShapeAnd: {
+        return: dom.IntersectionType;
+    };
+    ShapeNot: {
+        return: never;
+    };
+    ShapeExternal: {
+        return: never;
+    };
+}, null>;
+//# sourceMappingURL=ShexJTypingTransformer.d.ts.map

package/dist/schema-converter/transformers/ShexJTypingTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShexJTypingTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJTypingTransformer.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,eAAO,MAAM,4BAA4B,aAAoB,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7D;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAOvC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAc7C;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC9B,GAAG,MAAM,GAAG,SAAS,CAgBrB;AAyPD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAA;KAAE;eAClC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;WACxC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;YACnC;QAAE,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,oBAAoB,CAAA;KAAE;sBAC3C;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,CAAA;KAAE;oBACrC;QAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAA;KAAE;aAC3B;QAAE,MAAM,EAAE,GAAG,CAAC,SAAS,CAAA;KAAE;cACxB;QAAE,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAA;KAAE;cAChC;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QAyctC,CAAC"}