skir-cc-gen 0.0.1

package/client/skir.testing.h

@@ -0,0 +1,282 @@
+// Skir client library for testing
+
+#ifndef SKIR_SKIR_TESTING_H
+#define SKIR_SKIR_TESTING_H
+
+#include <gtest/gtest.h>
+
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/nullability.h"
+#include "absl/log/die_if_null.h"
+#include "gmock/gmock.h"
+#include "skir.h"
+
+namespace testing {
+namespace skirout {
+template <typename Struct>
+struct StructIs {
+  static_assert(skir::reflection::IsStruct<Struct>());
+  static_assert(false, "did you forget to include the *.testing.h file?");
+};
+}  // namespace skirout
+
+namespace skir_internal {
+template <typename Matcher>
+bool IsAnythingMatcher(const Matcher& matcher) {
+  static const std::string* absl_nonnull const kIsAnything = []() {
+    std::stringstream ss;
+    _.DescribeTo(&ss);
+    return new std::string(ss.str());
+  }();
+  std::stringstream ss;
+  matcher.DescribeTo(&ss);
+  return ss.str() == *kIsAnything;
+}
+
+namespace field_matcher {
+
+// Helper function to do comma folding in C++11.
+// The array ensures left-to-right order of evaluation.
+// Usage: VariadicExpand({expr...});
+template <typename T, size_t N>
+void VariadicExpand(const T (&)[N]) {}
+
+template <typename Getter, typename Matcher>
+std::nullopt_t DescribeTo(const std::pair<Getter, Matcher>& field_matcher,
+                          ::std::ostream* absl_nonnull os, bool& first) {
+  const Matcher& matcher = field_matcher.second;
+  if (IsAnythingMatcher(matcher)) return std::nullopt;
+  *os << (first ? "" : ", and ") << "has field " << Getter::kFieldName
+      << " that ";
+  matcher.DescribeTo(os);
+  first = false;
+  return std::nullopt;
+}
+
+template <typename Getter, typename Matcher>
+std::nullopt_t DescribeNegationTo(
+    const std::pair<Getter, Matcher>& field_matcher,
+    ::std::ostream* absl_nonnull os, bool& first) {
+  const Matcher& matcher = field_matcher.second;
+
+  if (IsAnythingMatcher(matcher)) return std::nullopt;
+  *os << (first ? "" : ", or ") << "has field " << Getter::kFieldName
+      << " that ";
+  matcher.DescribeNegationTo(os);
+  first = false;
+  return std::nullopt;
+}
+
+template <size_t I, typename Struct, typename FieldMatcher>
+std::nullopt_t MatchAndExplain(
+    const FieldMatcher& field_matcher, const Struct& t,
+    StringMatchResultListener* absl_nonnull inner_listener,
+    size_t& failed_pos) {
+  if (failed_pos != ~size_t{}) return std::nullopt;
+  const auto& [getter, matcher] = field_matcher;
+  if (IsAnythingMatcher(matcher)) return std::nullopt;
+  if (!matcher.MatchAndExplain(getter(t), inner_listener)) {
+    failed_pos = I;
+  }
+  return std::nullopt;
+}
+
+template <typename FieldMatcher, typename Struct>
+bool Matches(const FieldMatcher& field_matcher, const Struct& t) {
+  const auto& [getter, matcher] = field_matcher;
+  if (IsAnythingMatcher(matcher)) return true;
+  return matcher.Matches(getter(t));
+}
+
+}  // namespace field_matcher
+
+template <typename Struct, typename FieldMatchers, typename StructSize>
+class StructIsMatcherImpl;
+
+template <typename Struct, typename FieldMatchers, size_t... I>
+class StructIsMatcherImpl<Struct, FieldMatchers, std::index_sequence<I...>>
+    : public MatcherInterface<const Struct&> {
+ public:
+  explicit StructIsMatcherImpl(FieldMatchers matchers)
+      : matchers_(std::move(matchers)) {
+    field_matcher::VariadicExpand({(field_names_.emplace_back(
+        decltype(std::get<I>(matchers_).first)::kFieldName))...});
+  }
+
+  void DescribeTo(::std::ostream* absl_nonnull os) const override {
+    bool first = true;
+    field_matcher::VariadicExpand(
+        {(field_matcher::DescribeTo(std::get<I>(matchers_), os, first))...});
+    if (first) {
+      *os << "is anything";
+    }
+  }
+
+  void DescribeNegationTo(::std::ostream* absl_nonnull os) const override {
+    bool first = true;
+    field_matcher::VariadicExpand({(field_matcher::DescribeNegationTo(
+        std::get<I>(matchers_), os, first))...});
+    if (first) {
+      *os << "never matches";
+    }
+  }
+
+  bool MatchAndExplain(const Struct& t, MatchResultListener* absl_nonnull
+                                            listener) const override {
+    return MatchInternal(t, listener);
+  }
+
+ private:
+  bool MatchInternal(const Struct& t,
+                     MatchResultListener* absl_nonnull listener) const {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      bool good = true;
+      field_matcher::VariadicExpand(
+          {good =
+               good && field_matcher::Matches(std::get<I>(matchers_), t)...});
+      return good;
+    }
+    size_t failed_pos = ~size_t{};
+    std::vector<StringMatchResultListener> inner_listener(sizeof...(I));
+    field_matcher::VariadicExpand({field_matcher::MatchAndExplain<I>(
+        std::get<I>(matchers_), t, &inner_listener[I], failed_pos)...});
+    if (failed_pos != ~size_t{}) {
+      *listener << "whose field " << field_names_[failed_pos]
+                << " does not match";
+      const std::string explanation = inner_listener[failed_pos].str();
+      if (!explanation.empty() && listener->stream() != nullptr) {
+        *listener->stream() << ", " << explanation;
+      }
+      return false;
+    }
+    *listener << "whose all elements match";
+    const char* separator = ", where";
+    for (size_t index = 0; index < sizeof...(I); ++index) {
+      const std::string str = inner_listener[index].str();
+      if (!str.empty()) {
+        *listener << separator << " field " << field_names_[index]
+                  << " is a value " << str;
+        separator = ", and";
+      }
+    }
+    return true;
+  }
+
+  FieldMatchers matchers_;
+  std::vector<absl::string_view> field_names_;
+};
+
+template <typename Struct, typename... FieldMatcher>
+Matcher<Struct> StructIs(FieldMatcher... matchers) {
+  return Matcher<Struct>(
+      new StructIsMatcherImpl<Struct, tuple<FieldMatcher...>,
+                              std::index_sequence_for<FieldMatcher...>>(
+          std::make_tuple(matchers...)));
+}
+
+template <typename Option, typename InnerMatcher>
+class EnumValueIsMatcher {
+ public:
+  explicit EnumValueIsMatcher(InnerMatcher matcher)
+      : matcher_(std::move(matcher)) {}
+
+  template <typename Enum>
+  operator Matcher<Enum>() const {
+    return Matcher<Enum>(new Impl<Enum>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular enum type.
+  template <typename Enum>
+  class Impl : public MatcherInterface<const Enum&> {
+   public:
+    using value_type =
+        decltype(*Option::get_or_null(std::declval<const Enum&>()));
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<const value_type&>(matcher)) {}
+
+    void DescribeTo(::std::ostream* absl_nonnull os) const override {
+      *os << "is a " << Option::kVariantName;
+      if (!IsAnythingMatcher(matcher_)) {
+        *os << " that ";
+        matcher_.DescribeTo(os);
+      }
+    }
+
+    void DescribeNegationTo(::std::ostream* absl_nonnull os) const override {
+      *os << "is not a " << Option::kVariantName;
+      if (!IsAnythingMatcher(matcher_)) {
+        *os << " that ";
+        matcher_.DescribeTo(os);
+      }
+    }
+
+    bool MatchAndExplain(const Enum& e, MatchResultListener* absl_nonnull
+                                            listener) const override {
+      const auto* actual_value = Option::get_or_null(e);
+      if (actual_value == nullptr) {
+        *listener << "which is " << e;
+        return false;
+      } else {
+        *listener << "which is ";
+        return MatchPrintAndExplain(*actual_value, matcher_, listener);
+      }
+    }
+
+   private:
+    const Matcher<value_type> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+template <typename Option, typename InnerMatcher>
+EnumValueIsMatcher<Option, InnerMatcher> EnumValueIs(InnerMatcher matcher) {
+  return EnumValueIsMatcher<Option, InnerMatcher>(std::move(matcher));
+}
+
+template <typename FakeOrMockApiImpl>
+class ClientForTesting : public ::skir::service::Client {
+ public:
+  explicit ClientForTesting(FakeOrMockApiImpl* absl_nonnull api_impl)
+      : api_impl_(*ABSL_DIE_IF_NULL(api_impl)) {}
+
+  virtual ~ClientForTesting() = default;
+
+  absl::StatusOr<std::string> operator()(
+      absl::string_view request_data,
+      const skir::service::HttpHeaders& request_headers,
+      skir::service::HttpHeaders& response_headers) const override {
+    return ::skir::service::HandleRequest(api_impl_, request_data,
+                                          request_headers, response_headers)
+        .AsStatus();
+  }
+
+ private:
+  FakeOrMockApiImpl& api_impl_;
+};
+
+}  // namespace skir_internal
+}  // namespace testing
+
+namespace skir {
+namespace service {
+
+template <typename FakeOrMockApiImpl>
+std::unique_ptr<::skir::service::Client> MakeClientForTesting(
+    FakeOrMockApiImpl* absl_nonnull api_impl) {
+  return std::make_unique<
+      testing::skir_internal::ClientForTesting<FakeOrMockApiImpl>>(api_impl);
+}
+
+}  // namespace service
+}  // namespace skir
+
+#endif

package/dist/enum_field.d.ts

@@ -0,0 +1,33 @@
+import { Doc, Field } from "skir-internal";
+import { TypeSpeller } from "./type_speller.js";
+interface MutableEnumField {
+    /** As specified in the .skir file. */
+    readonly fieldName: string;
+    /** Examples: "bool", "Foo". Empty if the field is a constant field. */
+    readonly valueType: string;
+    /** Examples: "bool", "foo::Foo". Empty if the field is a constant field. */
+    readonly valueTypeWithNamespace: string;
+    /** As specified in the .skir file. */
+    fieldNumber: number;
+    /** Whether the field is the special UNKNOWN field. */
+    isUnknownField: boolean;
+    /** Examples: "f_field", "wrap_field". */
+    readonly structType: string;
+    /** Example: "wrap_field_type". Empty if the field is a constant field. */
+    readonly typeAlias: string;
+    /** kField or wrap_field. */
+    readonly identifier: string;
+    /** kConstField or kValField */
+    readonly kindEnumerator: string;
+    /**
+     * True if the field is a wrapper field and the value should be allocated on
+     * the
+     heap.
+     */
+    readonly usePointer: boolean;
+    readonly doc: Doc;
+}
+export type EnumField = Readonly<MutableEnumField>;
+export declare function getEnumFields(fields: readonly Field[], typeSpeller: TypeSpeller): readonly EnumField[];
+export {};
+//# sourceMappingURL=enum_field.d.ts.map

package/dist/enum_field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum_field.d.ts","sourceRoot":"","sources":["../src/enum_field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,EAA6B,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,UAAU,gBAAgB;IACxB,sCAAsC;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,cAAc,EAAE,OAAO,CAAC;IACxB,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;CACnB;AAED,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC;AAEnD,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,WAAW,EAAE,WAAW,GACvB,SAAS,SAAS,EAAE,CActB"}

package/dist/enum_field.js

@@ -0,0 +1,85 @@
+import { convertCase } from "skir-internal";
+export function getEnumFields(fields, typeSpeller) {
+    const result = [];
+    result.push(makeUnknownField());
+    for (const inField of fields) {
+        let outField;
+        if (inField.type) {
+            outField = makeWrapperField(inField, inField.doc, typeSpeller);
+        }
+        else {
+            outField = makeConstantField(inField.name.text, inField.doc);
+        }
+        outField.fieldNumber = inField.number;
+        result.push(outField);
+    }
+    return result;
+}
+function makeUnknownField() {
+    return {
+        fieldName: "?",
+        valueType: "",
+        valueTypeWithNamespace: "",
+        fieldNumber: 0,
+        isUnknownField: true,
+        structType: `k_unknown`,
+        typeAlias: "",
+        identifier: `kUnknown`,
+        kindEnumerator: `kUnknown`,
+        usePointer: false,
+        doc: { text: "", pieces: [] },
+    };
+}
+function makeConstantField(fieldName, doc) {
+    const lowerUnderscore = convertCase(fieldName, "lower_underscore");
+    const upperCamel = convertCase(fieldName, "UpperCamel");
+    return {
+        fieldName: fieldName,
+        valueType: "",
+        valueTypeWithNamespace: "",
+        fieldNumber: 0,
+        isUnknownField: false,
+        structType: `k_${lowerUnderscore}`,
+        typeAlias: "",
+        identifier: `k${upperCamel}`,
+        kindEnumerator: `k${upperCamel}Const`,
+        usePointer: false,
+        doc: doc,
+    };
+}
+function makeWrapperField(field, doc, typeSpeller) {
+    const fieldName = field.name.text;
+    const upperCamel = convertCase(fieldName, "UpperCamel");
+    const type = field.type;
+    return {
+        fieldName: fieldName,
+        valueType: typeSpeller.getCcType(type),
+        valueTypeWithNamespace: typeSpeller.getCcType(type, {
+            forceNamespace: true,
+        }),
+        fieldNumber: 0,
+        isUnknownField: false,
+        structType: `wrap_${fieldName}`,
+        typeAlias: `wrap_${fieldName}_type`,
+        identifier: `wrap_${fieldName}`,
+        kindEnumerator: `k${upperCamel}Wrapper`,
+        usePointer: usePointer(field.type),
+        doc: doc,
+    };
+}
+function usePointer(type) {
+    if (type.kind !== "primitive")
+        return true;
+    switch (type.primitive) {
+        case "bool":
+        case "int32":
+        case "int64":
+        case "uint64":
+        case "float32":
+        case "float64":
+        case "timestamp":
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=enum_field.js.map

package/dist/enum_field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum_field.js","sourceRoot":"","sources":["../src/enum_field.ts"],"names":[],"mappings":"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"}

package/dist/enum_variant.d.ts

@@ -0,0 +1,31 @@
+import { Doc, Field } from "skir-internal";
+import { TypeSpeller } from "./type_speller.js";
+interface MutableEnumVariant {
+    /** As specified in the .skir file. */
+    readonly variantName: string;
+    /** Examples: "bool", "Foo". Empty if the variant is a constant. */
+    readonly valueType: string;
+    /** Examples: "bool", "foo::Foo". Empty if the variant is a constant. */
+    readonly valueTypeWithNamespace: string;
+    /** As specified in the .skir file. */
+    variantNumber: number;
+    /** Whether the variant is the special UNKNOWN variant. */
+    isUnknownVariant: boolean;
+    /** Examples: "k_variant", "wrap_variant". */
+    readonly structType: string;
+    /** Example: "wrap_variant_type". Empty if the variant is a constant. */
+    readonly typeAlias: string;
+    /** kVariant or wrap_variant. */
+    readonly identifier: string;
+    /** kConstVariant or kValVariant */
+    readonly kindEnumerator: string;
+    /**
+     * True if the variant is a wrapper and the value should be allocated on the heap.
+     */
+    readonly usePointer: boolean;
+    readonly doc: Doc;
+}
+export type EnumVariant = Readonly<MutableEnumVariant>;
+export declare function getEnumVariants(variants: readonly Field[], typeSpeller: TypeSpeller): readonly EnumVariant[];
+export {};
+//# sourceMappingURL=enum_variant.d.ts.map

package/dist/enum_variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum_variant.d.ts","sourceRoot":"","sources":["../src/enum_variant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,KAAK,EAA6B,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,UAAU,kBAAkB;IAC1B,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,mCAAmC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;CACnB;AAED,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC;AAEvD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,KAAK,EAAE,EAC1B,WAAW,EAAE,WAAW,GACvB,SAAS,WAAW,EAAE,CAcxB"}

package/dist/enum_variant.js

@@ -0,0 +1,85 @@
+import { convertCase } from "skir-internal";
+export function getEnumVariants(variants, typeSpeller) {
+    const result = [];
+    result.push(makeUnknownVariant());
+    for (const inVariant of variants) {
+        let outVariant;
+        if (inVariant.type) {
+            outVariant = makeWrapperVariant(inVariant, inVariant.doc, typeSpeller);
+        }
+        else {
+            outVariant = makeConstantVariant(inVariant.name.text, inVariant.doc);
+        }
+        outVariant.variantNumber = inVariant.number;
+        result.push(outVariant);
+    }
+    return result;
+}
+function makeUnknownVariant() {
+    return {
+        variantName: "?",
+        valueType: "",
+        valueTypeWithNamespace: "",
+        variantNumber: 0,
+        isUnknownVariant: true,
+        structType: `k_unknown`,
+        typeAlias: "",
+        identifier: `kUnknown`,
+        kindEnumerator: `kUnknown`,
+        usePointer: false,
+        doc: { text: "", pieces: [] },
+    };
+}
+function makeConstantVariant(variantName, doc) {
+    const lowerUnderscore = convertCase(variantName, "lower_underscore");
+    const upperCamel = convertCase(variantName, "UpperCamel");
+    return {
+        variantName: variantName,
+        valueType: "",
+        valueTypeWithNamespace: "",
+        variantNumber: 0,
+        isUnknownVariant: false,
+        structType: `k_${lowerUnderscore}`,
+        typeAlias: "",
+        identifier: `k${upperCamel}`,
+        kindEnumerator: `k${upperCamel}Const`,
+        usePointer: false,
+        doc: doc,
+    };
+}
+function makeWrapperVariant(variant, doc, typeSpeller) {
+    const variantName = variant.name.text;
+    const upperCamel = convertCase(variantName, "UpperCamel");
+    const type = variant.type;
+    return {
+        variantName: variantName,
+        valueType: typeSpeller.getCcType(type),
+        valueTypeWithNamespace: typeSpeller.getCcType(type, {
+            forceNamespace: true,
+        }),
+        variantNumber: 0,
+        isUnknownVariant: false,
+        structType: `wrap_${variantName}`,
+        typeAlias: `wrap_${variantName}_type`,
+        identifier: `wrap_${variantName}`,
+        kindEnumerator: `k${upperCamel}Wrapper`,
+        usePointer: usePointer(variant.type),
+        doc: doc,
+    };
+}
+function usePointer(type) {
+    if (type.kind !== "primitive")
+        return true;
+    switch (type.primitive) {
+        case "bool":
+        case "int32":
+        case "int64":
+        case "uint64":
+        case "float32":
+        case "float64":
+        case "timestamp":
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=enum_variant.js.map

package/dist/enum_variant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum_variant.js","sourceRoot":"","sources":["../src/enum_variant.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { type CodeGenerator } from "skir-internal";
+import { z } from "zod";
+declare const Config: z.ZodObject<{
+    writeGoogleTestHeaders: z.ZodBoolean;
+}, z.core.$strip>;
+type Config = z.infer<typeof Config>;
+declare class CcCodeGenerator implements CodeGenerator<Config> {
+    readonly id = "cc";
+    readonly configType: z.ZodObject<{
+        writeGoogleTestHeaders: z.ZodBoolean;
+    }, z.core.$strip>;
+    readonly version = "1.0.0";
+    generateCode(input: CodeGenerator.Input<Config>): CodeGenerator.Output;
+}
+export declare const GENERATOR: CcCodeGenerator;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAWnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,QAAA,MAAM,MAAM;;iBAEV,CAAC;AAEH,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAErC,cAAM,eAAgB,YAAW,aAAa,CAAC,MAAM,CAAC;IACpD,QAAQ,CAAC,EAAE,QAAQ;IACnB,QAAQ,CAAC,UAAU;;sBAAU;IAC7B,QAAQ,CAAC,OAAO,WAAW;IAE3B,YAAY,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM;CAwBvE;AAm9DD,eAAO,MAAM,SAAS,iBAAwB,CAAC"}