@blinkk/root-cms 2.0.0-rc.1 → 2.0.0

package/dist/plugin.js

@@ -33,18 +33,18 @@ async function generateTypes() {
   console.log("saved root-cms.d.ts!");
 }
 async function generateSchemaDts(outputPath, schemas) {
-  const results = [TEMPLATE];
+  const dtsFormatter = new DtsFormatter();
   for (const fileId in schemas) {
     const schema = schemas[fileId];
-    results.push(renderSchema(fileId, schema));
+    dtsFormatter.addSchemaFile(fileId, schema);
   }
-  const output = results.join("\n\n").replaceAll("/**  ", "/** ").replaceAll("  */", " */").replace(/\r\n|\r|\n/g, "\n");
+  const output = dtsFormatter.toString();
   await fs.writeFile(outputPath, output, "utf-8");
 }
-function fieldProperty(field) {
+function fieldProperty(field, options) {
   const prop = dom.create.property(
     field.id,
-    fieldType(field),
+    fieldType(field, options),
     dom.DeclarationFlags.Optional
   );
   const jsdoc = [];
@@ -63,9 +63,9 @@ function fieldProperty(field) {
   }
   return prop;
 }
-function fieldType(field) {
+function fieldType(field, options) {
   if (field.type === "array") {
-    return dom.type.array(fieldType(field.of));
+    return dom.type.array(fieldType(field.of, options));
   }
   if (field.type === "boolean") {
     return dom.type.boolean;
@@ -76,19 +76,53 @@ function fieldType(field) {
   if (field.type === "datetime") {
     return dom.type.number;
   }
+  if (field.type === "file") {
+    const fileType = dom.create.namedTypeReference("RootCMSFile");
+    return fileType;
+  }
   if (field.type === "image") {
     const imageType = dom.create.namedTypeReference("RootCMSImage");
     return imageType;
   }
-  if (field.type === "file") {
-    return dom.create.objectType([dom.create.property("src", dom.type.string)]);
-  }
   if (field.type === "multiselect") {
     return dom.type.array(dom.type.string);
   }
   if (field.type === "oneof") {
-    const oneofType = dom.create.namedTypeReference("RootCMSOneOf");
-    return oneofType;
+    const oneOf = dom.create.namedTypeReference("RootCMSOneOf");
+    if (field.types && Array.isArray(field.types)) {
+      const unionTypes = [];
+      field.types.forEach((schema) => {
+        if (!schema.name) {
+          return;
+        }
+        const cleanName = alphanumeric(schema.name);
+        const oneOfTypeId = `${cleanName}Fields`;
+        if (!options.oneOfTypes[oneOfTypeId]) {
+          const oneOfTypeInterface = dom.create.interface(
+            oneOfTypeId,
+            dom.DeclarationFlags.Export
+          );
+          if (schema.description) {
+            oneOfTypeInterface.jsDocComment = schema.description;
+          }
+          const oneOfTypeFields = schema.fields || [];
+          oneOfTypeFields.forEach((f) => {
+            oneOfTypeInterface.members.push(fieldProperty(f, options));
+          });
+          options.oneOfTypes[oneOfTypeId] = oneOfTypeInterface;
+        }
+        const oneOfOption = dom.create.namedTypeReference("RootCMSOneOfOption");
+        oneOfOption.typeArguments = [
+          dom.type.stringLiteral(schema.name),
+          dom.create.namedTypeReference(oneOfTypeId)
+        ];
+        unionTypes.push(oneOfOption);
+      });
+      if (unionTypes.length > 0) {
+        oneOf.typeArguments = [dom.create.union(unionTypes)];
+      }
+    }
+    return oneOf;
   }
   if (field.type === "reference") {
     const referenceType = dom.create.namedTypeReference("RootCMSReference");
@@ -105,70 +139,36 @@ function fieldType(field) {
     return dom.type.string;
   }
   if (field.type === "object") {
-    const subproperties = (field.fields || []).map((f) => fieldProperty(f));
+    const subproperties = (field.fields || []).map(
+      (f) => fieldProperty(f, options)
+    );
     return dom.create.objectType(subproperties);
   }
   return dom.type.unknown;
 }
-function renderSchema(fileId, schema) {
-  const jsdoc = `Generated from \`${fileId}\`.`;
-  const id = alphanumeric(path2.parse(fileId).name.split(".")[0]);
-  const fieldsInterface = `${id}Fields`;
-  const fields = dom.create.interface(
-    fieldsInterface,
-    dom.DeclarationFlags.Export
-  );
-  fields.jsDocComment = jsdoc;
-  for (const field of schema.fields) {
-    if (!field.id) {
-      continue;
-    }
-    fields.members.push(fieldProperty(field));
-  }
-  const fieldsTypeOutput = dom.emit(fields, { singleLineJsDocComments: true }).trim();
-  if (fileId.startsWith("/collections/")) {
-    const baseType = dom.create.namedTypeReference("RootCMSDoc");
-    baseType.typeArguments.push(dom.create.namedTypeReference(fieldsInterface));
-    const docType = dom.create.alias(
-      `${id}Doc`,
-      baseType,
-      dom.DeclarationFlags.Export
-    );
-    docType.jsDocComment = jsdoc;
-    const docTypeOutput = dom.emit(docType, { singleLineJsDocComments: true }).trim();
-    return reindent(fieldsTypeOutput + "\n\n" + docTypeOutput);
-  }
-  return reindent(fieldsTypeOutput);
-}
-function reindent(input) {
-  const lines = input.split("\n");
-  const results = [];
-  for (const line of lines) {
-    const convertedLine = line.replace(/ {4}/g, "  ");
-    results.push(convertedLine);
-  }
-  return results.join("\n");
-}
 function alphanumeric(input) {
   return input.replace(/[^a-zA-Z0-9]/g, "");
 }
-var __dirname, TEMPLATE;
+var __dirname, TEMPLATE, DtsFormatter;
 var init_generate_types = __esm({
   "cli/generate-types.ts"() {
     "use strict";
     __dirname = path2.dirname(fileURLToPath(import.meta.url));
-    TEMPLATE = `/** Root.js CMS types. This file is autogenerated. */
+    TEMPLATE = `/* eslint-disable */
+/** Root.js CMS types. This file is autogenerated. */
 
-export interface RootCMSImage {
+export interface RootCMSFile {
   src: string;
   width?: number;
   height?: number;
   alt?: string;
 }
 
-export type RootCMSOneOf<T = any> = T & {
-  _type: string;
-};
+export type RootCMSImage = RootCMSFile;
+
+export type RootCMSOneOf<T = any> = T;
+
+export type RootCMSOneOfOption<T, Base> = Base & {_type: T};
 
 export interface RootCMSRichTextBlock {
   type: string;
@@ -210,6 +210,99 @@ export interface RootCMSDoc<Fields extends {}> {
   /** User-entered field values from the CMS. */
   fields?: Fields;
 }`;
+    DtsFormatter = class {
+      constructor() {
+        /**
+         * Field types defined in either `.schema.ts` files or used by `oneOf()`
+         * fields.
+         */
+        this.fieldsTypes = {};
+        /**
+         * For `collections/*.schema.ts` files, output a corresponding "RootCMSDoc"
+         * type. For example, `collections/BlogPosts.schema.ts` would output a type
+         * called `BlogPostsDoc`.
+         */
+        this.docTypes = {};
+      }
+      /** Adds the types for a `.schema.ts` file to the `.d.ts` file. */
+      addSchemaFile(fileId, schema) {
+        const jsdoc = `Generated from \`${fileId}\`.`;
+        const typeId = alphanumeric(path2.parse(fileId).name.split(".")[0]);
+        const oneOfTypes = {};
+        const fieldsTypeId = `${typeId}Fields`;
+        const fieldsType = dom.create.interface(
+          fieldsTypeId,
+          dom.DeclarationFlags.Export
+        );
+        fieldsType.jsDocComment = jsdoc;
+        for (const field of schema.fields) {
+          if (!field.id) {
+            continue;
+          }
+          fieldsType.members.push(fieldProperty(field, { typeId, oneOfTypes }));
+        }
+        for (const oneOfTypeId in oneOfTypes) {
+          if (!this.fieldsTypes[fieldsTypeId]) {
+            this.fieldsTypes[oneOfTypeId] = oneOfTypes[oneOfTypeId];
+          }
+        }
+        this.fieldsTypes[fieldsTypeId] = fieldsType;
+        if (fileId.startsWith("/collections/")) {
+          const docTypeId = `${typeId}Doc`;
+          const baseType = dom.create.namedTypeReference("RootCMSDoc");
+          baseType.typeArguments.push(dom.create.namedTypeReference(fieldsTypeId));
+          const docType = dom.create.alias(
+            docTypeId,
+            baseType,
+            dom.DeclarationFlags.Export
+          );
+          docType.jsDocComment = jsdoc;
+          this.docTypes[docTypeId] = docType;
+        }
+      }
+      /** Generates the `.d.ts` output as a string. */
+      toString() {
+        const results = [TEMPLATE];
+        const sortedFieldsTypes = Object.keys(this.fieldsTypes).sort();
+        for (const fieldsTypeId of sortedFieldsTypes) {
+          const fieldsType = this.fieldsTypes[fieldsTypeId];
+          results.push(this.typeToString(fieldsType));
+          const docTypeId = this.fieldsTypeToDocType(fieldsTypeId);
+          const docType = this.docTypes[docTypeId];
+          if (docType) {
+            results.push(this.typeToString(docType));
+          }
+        }
+        const output = results.join("\n\n").replaceAll("/**  ", "/** ").replaceAll("  */", " */").replace(/\r\n|\r|\n/g, "\n") + "\n";
+        return output;
+      }
+      /**
+       * Converts "<Name>Fields" to "<Name>Doc".
+       */
+      fieldsTypeToDocType(fieldsTypeId) {
+        if (!fieldsTypeId.endsWith("Fields")) {
+          throw new Error(`"${fieldsTypeId}" should be suffixed with "Fields"`);
+        }
+        const name = fieldsTypeId.slice(0, -6);
+        return `${name}Doc`;
+      }
+      typeToString(type2) {
+        return this.reformatOutput(dom.emit(type2, { singleLineJsDocComments: true }));
+      }
+      /**
+       * Formats the output to Google style conventions, e.g. 2-space indents and
+       * single quote strings.
+       */
+      reformatOutput(input) {
+        const lines = input.trim().split("\n");
+        const results = [];
+        for (const line of lines) {
+          const convertedLine = line.replace(/ {4}/g, "  ").replaceAll('"', "'");
+          results.push(convertedLine);
+        }
+        return results.join("\n");
+      }
+    };
   }
 });
 
@@ -233,12 +326,10 @@ import { multipartMiddleware } from "@blinkk/root/middleware";
 
 // core/ai.ts
 import crypto from "node:crypto";
-import { generate } from "@genkit-ai/ai";
-import { configureGenkit } from "@genkit-ai/core";
 import { vertexAI } from "@genkit-ai/vertexai";
-import { gemini15ProPreview, gemini15FlashPreview } from "@genkit-ai/vertexai";
 import { Timestamp } from "firebase-admin/firestore";
-var genkitIsConfigured = false;
+import { genkit } from "genkit";
+var DEFAULT_MODEL = "vertexai/gemini-2.5-flash";
 var Chat = class {
   constructor(chatClient, id, options) {
     var _a;
@@ -246,52 +337,46 @@ var Chat = class {
     this.cmsClient = chatClient.cmsClient;
     this.cmsPluginOptions = this.cmsClient.cmsPlugin.getConfig();
     this.id = id;
-    this.history = options == null ? void 0 : options.history;
-    this.model = options == null ? void 0 : options.model;
-    if (!this.model) {
-      if (typeof ((_a = this.cmsPluginOptions.experiments) == null ? void 0 : _a.ai) === "object") {
-        if (this.cmsPluginOptions.experiments.ai.model) {
-          this.model = this.cmsPluginOptions.experiments.ai.model;
-        }
-      }
-    }
+    this.history = (options == null ? void 0 : options.history) ?? [];
+    this.model = (options == null ? void 0 : options.model) || (typeof ((_a = this.cmsPluginOptions.experiments) == null ? void 0 : _a.ai) === "object" ? this.cmsPluginOptions.experiments.ai.model : void 0) || DEFAULT_MODEL;
+    const firebaseConfig = this.cmsPluginOptions.firebaseConfig;
+    this.ai = genkit({
+      plugins: [
+        vertexAI({
+          projectId: firebaseConfig.projectId,
+          location: firebaseConfig.location || "us-central1"
+        })
+      ]
+    });
   }
-  async sendPrompt(prompt) {
-    if (!genkitIsConfigured) {
-      const firebaseConfig = this.cmsPluginOptions.firebaseConfig;
-      configureGenkit({
-        plugins: [
-          vertexAI({
-            projectId: firebaseConfig.projectId,
-            // TODO(stevenle): figure out where to get this.
-            location: firebaseConfig.location || "us-central1"
-          })
-        ]
+  /** Builds the messages for the AI request. */
+  async buildMessages() {
+    const messages = this.history;
+    if (messages.length === 0) {
+      messages.push({
+        role: "system",
+        content: [{ text: await this.buildSystemPrompt() }]
       });
-      genkitIsConfigured = true;
-    }
-    let model = gemini15FlashPreview;
-    if (this.model === "gemini-1.5-pro") {
-      model = gemini15ProPreview;
     }
-    if (!this.history) {
-      await this.initHistory();
-    }
-    const res = await generate({
-      model,
-      prompt,
-      history: this.history
+    return messages;
+  }
+  async sendPrompt(prompt) {
+    const res = await this.ai.generate({
+      messages: await this.buildMessages(),
+      model: this.model,
+      prompt
     });
-    console.log(res.text());
-    const history = res.toHistory();
-    this.history = history;
-    await this.dbDoc().update({ history, modifiedAt: Timestamp.now() });
-    return res.text();
+    this.history = res.messages;
+    await this.dbDoc().update({
+      history: this.history,
+      modifiedAt: Timestamp.now()
+    });
+    return res.text;
   }
   dbDoc() {
     return this.chatClient.dbCollection().doc(this.id);
   }
-  async initHistory() {
+  async buildSystemPrompt() {
     const systemText = [
       `You are an assistant for a headless CMS called Root CMS which is used on a website called ${this.cmsPluginOptions.name || this.cmsPluginOptions.id}. Your job is to answer questions about the docs in the system, and if requested, help suggest changes to the JSON data in the docs. If you don't know the answer, just say that you don't know, don't try to make up an answer. Be friendly and playful with your messaging.`,
       "",
@@ -306,8 +391,7 @@ var Chat = class {
     pages.docs.forEach((doc) => {
       systemText.push(JSON.stringify(doc));
     });
-    this.history = [{ role: "system", content: [{ text: systemText.join("\n") }] }];
-    console.log(this.history);
+    return systemText.join("\n");
   }
 };
 var ChatClient = class {
@@ -315,17 +399,18 @@ var ChatClient = class {
     this.cmsClient = cmsClient;
     this.user = user;
   }
-  async createChat(options) {
+  async createChat() {
     const chatId = crypto.randomUUID();
     const docRef = this.dbCollection().doc(chatId);
+    const chat = new Chat(this, chatId);
     await docRef.set({
       id: chatId,
       createdBy: this.user,
       createdAt: Timestamp.now(),
       modifiedAt: Timestamp.now(),
-      model: (options == null ? void 0 : options.model) || "gemini-1.5-flash"
+      model: chat.model
     });
-    return new Chat(this, chatId);
+    return chat;
   }
   async getChat(chatId) {
     const docRef = this.dbCollection().doc(chatId);
@@ -354,10 +439,361 @@ var ChatClient = class {
 
 // core/client.ts
 import crypto2 from "node:crypto";
+import {
+  FieldValue as FieldValue2,
+  Timestamp as Timestamp3
+} from "firebase-admin/firestore";
+
+// core/translations-manager.ts
 import {
   FieldValue,
   Timestamp as Timestamp2
 } from "firebase-admin/firestore";
+
+// shared/strings.ts
+import fnv from "fnv-plus";
+function normalizeStr(str) {
+  const lines = str.trim().split("\n").map((line) => removeTrailingWhitespace(line));
+  return lines.join("\n");
+}
+function removeTrailingWhitespace(str) {
+  return str.trimEnd().replace(/&nbsp;$/, "");
+}
+function hashStr(str) {
+  if (!str || typeof str !== "string") {
+    throw new Error("input string is invalid");
+  }
+  return fnv.fast1a52hex(normalizeStr(str));
+}
+
+// core/translations-manager.ts
+var TRANSLATIONS_DB_PATH_FORMAT = "/Projects/{project}/TranslationsManager/{mode}/Translations";
+var TRANSLATIONS_LOCALE_DOC_DB_PATH_FORMAT = `${TRANSLATIONS_DB_PATH_FORMAT}/{id}:{locale}`;
+var TranslationsManager = class {
+  constructor(cmsClient) {
+    this.cmsClient = cmsClient;
+  }
+  /**
+   * Saves draft translations for a translations doc id.
+   *
+   * Example:
+   * ```
+   * const strings = {
+   *   'one': {es: 'uno', fr: 'un'},
+   *   'two': {es: 'dos', fr: 'deux'},
+   * };
+   * await tm.saveTranslations('Pages/index', strings);
+   * ```
+   */
+  async saveTranslations(id, strings, options) {
+    const mode = "draft";
+    const localesSet = /* @__PURE__ */ new Set();
+    Object.values(strings).forEach((entry) => {
+      Object.keys(entry).forEach((locale) => {
+        if (locale !== "source") {
+          localesSet.add(locale);
+        }
+      });
+    });
+    const batch = this.cmsClient.db.batch();
+    const locales = Array.from(localesSet);
+    locales.forEach((locale) => {
+      const updates = {
+        id,
+        locale,
+        sys: {
+          modifiedAt: Timestamp2.now(),
+          modifiedBy: (options == null ? void 0 : options.modifiedBy) || "root-cms-client"
+        },
+        strings: {}
+      };
+      if ((options == null ? void 0 : options.tags) && options.tags.length > 0) {
+        updates.tags = FieldValue.arrayUnion(...options.tags);
+      }
+      let numUpdates = 0;
+      const hashMap = this.toLocaleDocHashMap(strings, locale);
+      Object.entries(hashMap).forEach(([hash, translations]) => {
+        Object.entries(translations).forEach(([locale2, translation]) => {
+          if (translation) {
+            updates.strings[hash] ??= {};
+            updates.strings[hash][locale2] = translation;
+            numUpdates += 1;
+          }
+        });
+      });
+      if (numUpdates > 0) {
+        const localeDocPath = buildTranslationsLocaleDocDbPath({
+          project: this.cmsClient.projectId,
+          mode,
+          id,
+          locale
+        });
+        const localeDocRef = this.cmsClient.db.doc(localeDocPath);
+        batch.set(localeDocRef, updates, { merge: true });
+      }
+    });
+    await batch.commit();
+  }
+  /**
+   * Publishes a translations doc.
+   */
+  async publishTranslations(id, options) {
+    const db = this.cmsClient.db;
+    const project = this.cmsClient.projectId;
+    const draftPath = buildTranslationsDbPath({ project, mode: "draft" });
+    const query = db.collection(draftPath).where("id", "==", id);
+    const res = await query.get();
+    if (res.size === 0) {
+      console.warn(`no translations to publish for ${id}`);
+      return;
+    }
+    const batch = (options == null ? void 0 : options.batch) || db.batch();
+    res.docs.forEach((doc) => {
+      const translationsLocaleDoc = doc.data();
+      const sys = {
+        ...translationsLocaleDoc.sys,
+        publishedAt: Timestamp2.now(),
+        publishedBy: (options == null ? void 0 : options.publishedBy) || "root-cms-client"
+      };
+      batch.update(doc.ref, { sys });
+      const publishedDocPath = buildTranslationsLocaleDocDbPath({
+        project,
+        mode: "published",
+        id: translationsLocaleDoc.id,
+        locale: translationsLocaleDoc.locale
+      });
+      const publishedDocRef = db.doc(publishedDocPath);
+      batch.set(publishedDocRef, { ...translationsLocaleDoc, sys });
+    });
+    const shouldCommitBatch = !(options == null ? void 0 : options.batch);
+    if (shouldCommitBatch) {
+      await batch.commit();
+    }
+  }
+  /**
+   * Fetches translations from one or more translations docs in the translations
+   * manager.
+   *
+   * Example:
+   * ```
+   * await tm.loadTranslations();
+   * // =>
+   * // {
+   * //   "one": {"es": "uno", "fr": "un"},
+   * //   "two": {"es": "dos", "fr": "deux"}
+   * // }
+   * ```
+   *
+   * To load a specific set of translations docs by id:
+   * ```
+   * const translationsToLoad = ['Global/strings', 'Global/header', 'Global/footer', 'Pages/index'];
+   * await tm.loadTranslations({ids: translationsToLoad});
+   * // =>
+   * // {
+   * //   "one": {"es": "uno", "fr": "un"},
+   * //   "two": {"es": "dos", "fr": "deux"}
+   * // }
+   * ```
+   *
+   * To load a subset of locales (more performant):
+   * ```
+   * await tm.loadTranslations({locales: ['es']});
+   * // =>
+   * // {
+   * //   "one": {"es": "uno"},
+   * //   "two": {"es": "dos"}
+   * // }
+   * ```
+   */
+  async loadTranslations(options) {
+    const mode = (options == null ? void 0 : options.mode) || "published";
+    const dbPath = buildTranslationsDbPath({
+      project: this.cmsClient.projectId,
+      mode
+    });
+    let query = this.cmsClient.db.collection(dbPath);
+    if ((options == null ? void 0 : options.ids) && options.ids.length > 0) {
+      query = query.where("id", "in", options.ids);
+    }
+    if ((options == null ? void 0 : options.tags) && options.tags.length > 0) {
+      query = query.where("tags", "array-contains", options.tags);
+    }
+    if ((options == null ? void 0 : options.locales) && options.locales.length > 0) {
+      query = query.where("locale", "in", options.locales);
+    }
+    const results = await query.get();
+    const strings = {};
+    results.forEach((result) => {
+      const localeDoc = result.data();
+      Object.values(localeDoc.strings || {}).forEach((item) => {
+        strings[item.source] ??= { source: item.source };
+        strings[item.source][localeDoc.locale] = item.translation;
+      });
+    });
+    return strings;
+  }
+  /**
+   * Fetches translations for a given locale, with optional fallbacks.
+   * The return value is a map of source string to translated string.
+   *
+   * Example:
+   * ```
+   * await translationsDoc.loadTranslationsForLocale('es');
+   * // =>
+   * // {
+   * //   "one": "uno",
+   * //   "two": "dos",
+   * // }
+   * ```
+   */
+  async loadTranslationsForLocale(locale, options) {
+    const localeSet = /* @__PURE__ */ new Set([
+      locale,
+      ...(options == null ? void 0 : options.fallbackLocales) || []
+    ]);
+    const fallbackLocales = Array.from(localeSet);
+    const multiLocaleStrings = await this.loadTranslations({
+      mode: options == null ? void 0 : options.mode,
+      locales: fallbackLocales
+    });
+    return this.toSingleLocaleMap(multiLocaleStrings, fallbackLocales);
+  }
+  /**
+   * Converts a multi-locale translations map to a flat single-locale map,
+   * with optional support for fallback locales.
+   *
+   * ```
+   * const multiLocaleStrings = {
+   *   'one': {es: 'uno', fr: 'un'},
+   *   'two': {es: 'dos', fr: 'deux'}
+   * };
+   * translationsDoc.toSingleLocaleMap(multiLocaleStrings, ['es']);
+   * // =>
+   * // {
+   * //   "one": "uno",
+   * //   "two": "dos",
+   * // }
+   * ```
+   */
+  toSingleLocaleMap(multiLocaleStrings, fallbackLocales) {
+    const singleLocaleStrings = {};
+    Object.entries(multiLocaleStrings).forEach(([source, translations]) => {
+      let translation = source;
+      for (const locale of fallbackLocales) {
+        if (translations[locale]) {
+          translation = translations[locale];
+          break;
+        }
+      }
+      singleLocaleStrings[source] = translation;
+    });
+    return singleLocaleStrings;
+  }
+  /**
+   * Converts a multi-locale translations map to a single-locale hashed version,
+   * used for storage in in the DB.
+   *
+   * ```
+   * const multiLocaleStrings = {
+   *   'one': {es: 'uno', fr: 'un'},
+   *   'two': {es: 'dos', fr: 'deux'}
+   * };
+   * translationsDoc.toLocaleDocHashMap(multiLocaleStrings, 'es');
+   * // =>
+   * // {
+   * //   "<hash1>": {"source": "one", "translation": "uno"},
+   * //   "<hash2>": {"source": "two", "translation": "dos"},
+   * // }
+   * ```
+   *
+   * One reason for using hashes is because the DB has limits on the number of
+   * chars that can be used as the "key" in a object map.
+   */
+  toLocaleDocHashMap(multiLocaleStrings, locale) {
+    const hashMap = {};
+    Object.entries(multiLocaleStrings).forEach(([source, translations]) => {
+      const translation = translations[locale];
+      if (translation) {
+        const hash = hashStr(source);
+        hashMap[hash] = { source, translation };
+      }
+    });
+    return hashMap;
+  }
+  /**
+   * Import translations from the v1 system to the TranslationsManager.
+   */
+  async importTranslationsFromV1() {
+    var _a;
+    const projectId = this.cmsClient.projectId;
+    const db = this.cmsClient.db;
+    const dbPath = `Projects/${projectId}/Translations`;
+    const query = db.collection(dbPath);
+    const querySnapshot = await query.get();
+    if (querySnapshot.size === 0) {
+      return;
+    }
+    console.log(
+      "[root cms] importing v1 Translations to v2 TranslationsManager"
+    );
+    const translationsDocs = {};
+    querySnapshot.forEach((doc) => {
+      const translation = doc.data();
+      const source = this.cmsClient.normalizeString(translation.source);
+      delete translation.source;
+      const tags = translation.tags || [];
+      delete translation.tags;
+      for (const tag of tags) {
+        if (tag.includes("/")) {
+          const translationsId = tag;
+          translationsDocs[translationsId] ??= {
+            id: translationsId,
+            tags,
+            strings: {}
+          };
+          translationsDocs[translationsId].strings[source] = translation;
+        }
+      }
+    });
+    if (Object.keys(translationsDocs).length === 0) {
+      console.log("[root cms] no v1 translations to save");
+      return;
+    }
+    for (const docId in translationsDocs) {
+      const [collection, slug] = docId.split("/");
+      if (collection && slug) {
+        const doc = await this.cmsClient.getDoc(collection, slug, {
+          mode: "draft"
+        });
+        const linkedSheet = (_a = doc == null ? void 0 : doc.sys) == null ? void 0 : _a.l10nSheet;
+        if (linkedSheet) {
+          translationsDocs[docId].sys.linkedSheet = linkedSheet;
+        }
+      }
+    }
+    Object.entries(translationsDocs).forEach(([translationsId, data]) => {
+      const len = Object.keys(data.strings).length;
+      console.log(`[root cms] saving ${len} string(s) to ${translationsId}...`);
+      this.saveTranslations(translationsId, data.strings, {
+        tags: data.tags || [translationsId]
+      });
+    });
+  }
+};
+function buildTranslationsDbPath(options) {
+  return TRANSLATIONS_DB_PATH_FORMAT.replace(
+    "{project}",
+    options.project
+  ).replace("{mode}", options.mode);
+}
+function buildTranslationsLocaleDocDbPath(options) {
+  return TRANSLATIONS_LOCALE_DOC_DB_PATH_FORMAT.replace(
+    "{project}",
+    options.project
+  ).replace("{mode}", options.mode).replace("{id}", options.id.replaceAll("/", "--")).replace("{locale}", options.locale);
+}
+
+// core/client.ts
 var RootCMSClient = class {
   constructor(rootConfig) {
     this.rootConfig = rootConfig;
@@ -383,13 +819,19 @@ var RootCMSClient = class {
    */
   async getRawDoc(collectionId, slug, options) {
     const mode = options.mode;
-    const docRef = this.dbDocRef(collectionId, slug, { mode });
+    const modeCollection = mode === "draft" ? "Drafts" : "Published";
+    slug = slug.replaceAll("/", "--");
+    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;
+    const docRef = this.db.doc(dbPath);
     const doc = await docRef.get();
     if (doc.exists) {
       return doc.data();
     }
     return null;
   }
+  /**
+   * Firestore path for a collection.
+   */
   dbCollectionDocsPath(collectionId, options) {
     let modeCollection = "";
     if (options.mode === "draft") {
@@ -401,11 +843,17 @@ var RootCMSClient = class {
     }
     return `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;
   }
+  /**
+   * Firestore path for a content doc.
+   */
   dbDocPath(collectionId, slug, options) {
     const collectionDocsPath = this.dbCollectionDocsPath(collectionId, options);
     const normalizedSlug = slug.replaceAll("/", "--");
     return `${collectionDocsPath}/${normalizedSlug}`;
   }
+  /**
+   * Firestore doc ref for a content doc.
+   */
   dbDocRef(collectionId, slug, options) {
     const docPath = this.dbDocPath(collectionId, slug, options);
     return this.db.doc(docPath);
@@ -428,9 +876,9 @@ var RootCMSClient = class {
       slug,
       sys: {
         ...draftSys,
-        createdAt: draftSys.createdAt ?? Timestamp2.now(),
+        createdAt: draftSys.createdAt ?? Timestamp3.now(),
         createdBy: draftSys.createdBy ?? modifiedBy,
-        modifiedAt: Timestamp2.now(),
+        modifiedAt: Timestamp3.now(),
         modifiedBy,
         locales: (options == null ? void 0 : options.locales) ?? draftSys.locales ?? ["en"]
       },
@@ -526,6 +974,10 @@ var RootCMSClient = class {
     }
     let batchCount = 0;
     const batch = (options == null ? void 0 : options.batch) || this.db.batch();
+    const versionTags = ["published"];
+    if (options == null ? void 0 : options.releaseId) {
+      versionTags.push(`release:${options.releaseId}`);
+    }
     const publishedDocs = [];
     for (const doc of docs) {
       const { id, collection, slug, sys, fields } = doc;
@@ -538,7 +990,7 @@ var RootCMSClient = class {
       const publishedRef = this.db.doc(
         `${projectCollectionsPath}/${collection}/Published/${slug}`
       );
-      const firstPublishedAt = sys.firstPublishedAt ?? FieldValue.serverTimestamp();
+      const firstPublishedAt = sys.firstPublishedAt ?? FieldValue2.serverTimestamp();
       const firstPublishedBy = sys.firstPublishedBy ?? publishedBy;
       batch.set(publishedRef, {
         id,
@@ -549,24 +1001,43 @@ var RootCMSClient = class {
           ...sys,
           firstPublishedAt,
           firstPublishedBy,
-          publishedAt: FieldValue.serverTimestamp(),
+          publishedAt: FieldValue2.serverTimestamp(),
           publishedBy
         }
       });
       batchCount += 1;
+      const versionRef = this.db.doc(
+        `${projectCollectionsPath}/${collection}/Drafts/${slug}/Versions/${Date.now()}`
+      );
+      const versionData = {
+        id,
+        collection,
+        slug,
+        fields: fields || {},
+        sys: {
+          ...sys,
+          firstPublishedAt,
+          firstPublishedBy,
+          publishedAt: FieldValue2.serverTimestamp(),
+          publishedBy
+        }
+      };
+      if (versionTags.length) {
+        versionData.tags = versionTags;
+      }
+      batch.set(versionRef, versionData);
+      batchCount += 1;
       batch.delete(scheduledRef);
       batchCount += 1;
       batch.update(draftRef, {
-        "sys.scheduledAt": FieldValue.delete(),
-        "sys.scheduledBy": FieldValue.delete(),
+        "sys.scheduledAt": FieldValue2.delete(),
+        "sys.scheduledBy": FieldValue2.delete(),
         "sys.firstPublishedAt": firstPublishedAt,
         "sys.firstPublishedBy": firstPublishedBy,
-        "sys.publishedAt": FieldValue.serverTimestamp(),
+        "sys.publishedAt": FieldValue2.serverTimestamp(),
         "sys.publishedBy": publishedBy
       });
       batchCount += 1;
-      this.publishTranslationsDoc(doc.id, { batch });
-      batchCount += 2;
       publishedDocs.push(doc);
       if (batchCount >= 400) {
         await batch.commit();
@@ -613,6 +1084,7 @@ var RootCMSClient = class {
     }
     let batchCount = 0;
     const batch = this.db.batch();
+    const versionTags = ["published"];
     const publishedDocs = [];
     for (const doc of docs) {
       const { id, collection, slug, data } = doc;
@@ -637,24 +1109,41 @@ var RootCMSClient = class {
           ...sys,
           firstPublishedAt,
           firstPublishedBy,
-          publishedAt: FieldValue.serverTimestamp(),
+          publishedAt: FieldValue2.serverTimestamp(),
           publishedBy: scheduledBy || ""
         }
       });
       batchCount += 1;
+      const versionRef = this.db.doc(
+        `${projectCollectionsPath}/${collection}/Drafts/${slug}/Versions/${Date.now()}`
+      );
+      const versionData = {
+        id,
+        collection,
+        slug,
+        fields: data.fields || {},
+        sys: {
+          ...sys,
+          firstPublishedAt,
+          firstPublishedBy,
+          publishedAt: FieldValue2.serverTimestamp(),
+          publishedBy: scheduledBy || ""
+        },
+        tags: versionTags
+      };
+      batch.set(versionRef, versionData);
+      batchCount += 1;
       batch.delete(scheduledRef);
       batchCount += 1;
       batch.update(draftRef, {
-        "sys.scheduledAt": FieldValue.delete(),
-        "sys.scheduledBy": FieldValue.delete(),
+        "sys.scheduledAt": FieldValue2.delete(),
+        "sys.scheduledBy": FieldValue2.delete(),
         "sys.firstPublishedAt": firstPublishedAt,
         "sys.firstPublishedBy": firstPublishedBy,
-        "sys.publishedAt": FieldValue.serverTimestamp(),
+        "sys.publishedAt": FieldValue2.serverTimestamp(),
         "sys.publishedBy": scheduledBy || "root-cms-client"
       });
       batchCount += 1;
-      this.publishTranslationsDoc(doc.id, { batch });
-      batchCount += 2;
       publishedDocs.push(doc);
       if (batchCount >= 400) {
         await batch.commit();
@@ -674,50 +1163,31 @@ var RootCMSClient = class {
   async publishScheduledReleases() {
     const releasesPath = `Projects/${this.projectId}/Releases`;
     const now = Math.ceil((/* @__PURE__ */ new Date()).getTime());
-    const query = this.db.collection(releasesPath).where("scheduledAt", "<=", Timestamp2.fromMillis(now));
+    const query = this.db.collection(releasesPath).where("scheduledAt", "<=", Timestamp3.fromMillis(now));
     const querySnapshot = await query.get();
     for (const snapshot of querySnapshot.docs) {
       const release = snapshot.data();
       const batch = this.db.batch();
       const publishedBy = release.scheduledBy || "root-cms-client";
       batch.update(snapshot.ref, {
-        publishedAt: Timestamp2.now(),
+        publishedAt: Timestamp3.now(),
         publishedBy,
-        scheduledAt: FieldValue.delete(),
-        scheduledBy: FieldValue.delete()
+        scheduledAt: FieldValue2.delete(),
+        scheduledBy: FieldValue2.delete()
+      });
+      const dataSourceIds = release.dataSourceIds || [];
+      if (dataSourceIds.length > 0) {
+        await this.publishDataSources(dataSourceIds, {
+          publishedBy,
+          batch,
+          commitBatch: false
+        });
+      }
+      await this.publishDocs(release.docIds || [], {
+        publishedBy,
+        batch,
+        releaseId: release.id
       });
-      await this.publishDocs(release.docIds || [], { publishedBy, batch });
-    }
-  }
-  async publishTranslationsDoc(translationsId, options) {
-    const docSlug = translationsId.replaceAll("/", "--");
-    const draftRef = this.db.doc(
-      `Projects/${this.projectId}/TranslationsManager/draft/Translations/${docSlug}`
-    );
-    const snapshot = await draftRef.get();
-    if (!snapshot.exists) {
-      console.warn(`translations ${translationsId} does not exist`);
-      return;
-    }
-    const commitBatch = !(options == null ? void 0 : options.batch);
-    const batch = (options == null ? void 0 : options.batch) || this.db.batch();
-    batch.update(draftRef, {
-      "sys.publishedAt": Timestamp2.now(),
-      "sys.publishedBy": (options == null ? void 0 : options.publishedBy) || "root-cms-client"
-    });
-    const publishedRef = this.db.doc(
-      `Projects/${this.projectId}/TranslationsManager/published/Translations/${docSlug}`
-    );
-    const data = { ...snapshot.data() };
-    if (!data.sys) {
-      data.sys = {};
-    }
-    data.sys.publishedAt = Timestamp2.now();
-    data.sys.publishedBy = (options == null ? void 0 : options.publishedBy) || "root-cms-client";
-    batch.set(publishedRef, data);
-    if (commitBatch) {
-      await batch.commit();
-      this.logAction("translations.publish", { metadata: { translationsId } });
     }
   }
   /**
@@ -727,7 +1197,7 @@ var RootCMSClient = class {
     var _a;
     if ((_a = doc.sys) == null ? void 0 : _a.publishingLocked) {
       if (doc.sys.publishingLocked.until) {
-        const now = Timestamp2.now().toMillis();
+        const now = Timestamp3.now().toMillis();
         const until = doc.sys.publishingLocked.until.toMillis();
         return now < until;
       }
@@ -736,60 +1206,83 @@ var RootCMSClient = class {
     return false;
   }
   /**
-   * Loads all published strings in the db.
+   * Returns a `TranslationsManager` object for managing translations.
    *
+   * To get translations:
+   * ```
+   * await tm.loadTranslations({
+   *   ids: ['Global/strings', 'Pages/index'],
+   *   locales: ['es'],
+   * });
+   * ```
+   *
+   * NOTE: The `TranslationsManager` is a v2 feature that will eventually
+   * replace the v1 translations system.
+   */
+  getTranslationsManager() {
+    var _a;
+    const cmsPluginOptions = this.cmsPlugin.getConfig();
+    if ((_a = cmsPluginOptions.experiments) == null ? void 0 : _a.v2TranslationsManager) {
+      throw new Error(
+        "`v2TranslationsManager` is not enabled. update root.config.ts and add: `{experiments: {v2TranslationsManager: true}}`"
+      );
+    }
+    return new TranslationsManager(this);
+  }
+  /**
+   * Loads translations saved in the translations collection, optionally
+   * filtered by tag.
+   *
+   * Returns a map like:
    * ```
    * {
    *   "<hash>": {"source": "Hello", "es": "Hola", "fr": "Bonjour"},
    * }
    * ```
-   *
-   * @deprecated Use `createBatchRequest()` to fetch draft/published translations.
    */
   async loadTranslations(options) {
-    const dbPath = `Projects/${this.projectId}/TranslationsManager/published/Translations`;
-    const translationsMap = {};
-    const addTranslations = (hash, translations) => {
-      translationsMap[hash] = Object.assign(
-        translationsMap[hash] || {},
-        translations
-      );
-    };
+    const dbPath = `Projects/${this.projectId}/Translations`;
     let query = this.db.collection(dbPath);
-    if ((options == null ? void 0 : options.tags) && options.tags.length > 0) {
-      query = query.where("sys.tags", "array-contains-any", options.tags);
-    }
-    const snapshot = await query.get();
-    snapshot.forEach((doc) => {
-      const data = doc.data();
-      const strings = data.strings || {};
-      Object.entries(strings).forEach(([hash, translations]) => {
-        addTranslations(hash, translations);
-      });
+    if (options == null ? void 0 : options.tags) {
+      query = query.where("tags", "array-contains-any", options.tags);
+    }
+    const querySnapshot = await query.get();
+    const translationsMap = {};
+    querySnapshot.forEach((doc) => {
+      const hash = doc.id;
+      translationsMap[hash] = doc.data();
     });
     return translationsMap;
   }
-  async saveDraftTranslations(translationsId, translations, options) {
-    const docSlug = translationsId.replaceAll("/", "--");
-    const docPath = `Projects/${this.projectId}/TranslationsManager/draft/${docSlug}`;
-    const docRef = this.db.doc(docPath);
-    const snapshot = await docRef.get();
-    const data = snapshot.data() || {
-      id: translationsId.replaceAll("--", "/"),
-      sys: {},
-      strings: {}
-    };
-    data.sys.modifiedAt = Timestamp2.now();
-    data.sys.modifiedBy = (options == null ? void 0 : options.modifiedby) || "root-cms-client";
-    const strings = data.strings || {};
-    Object.entries(translations).forEach(([source, row]) => {
-      const normalizedSource = this.normalizeString(source);
-      const hash = this.getTranslationKey(normalizedSource);
-      strings[hash] = { ...strings[hash], ...row, source: normalizedSource };
+  /**
+   * Saves a map of translations, e.g.:
+   * ```
+   * await client.saveTranslations({
+   *   "Hello": {"es": "Hola", "fr": "Bonjour"},
+   * });
+   * ```
+   */
+  async saveTranslations(translations, tags) {
+    const translationsPath = `Projects/${this.projectId}/Translations`;
+    const batch = this.db.batch();
+    let batchCount = 0;
+    Object.entries(translations).forEach(([source, sourceTranslations]) => {
+      const hash = this.getTranslationKey(source);
+      const translationRef = this.db.doc(`${translationsPath}/${hash}`);
+      const data = {
+        ...sourceTranslations,
+        source: this.normalizeString(source)
+      };
+      if (tags) {
+        data.tags = FieldValue2.arrayUnion(...tags);
+      }
+      batch.set(translationRef, data, { merge: true });
+      batchCount += 1;
     });
-    data.strings = strings;
-    await docRef.set(data);
-    this.logAction("translations.save", { metadata: { translationsId } });
+    if (batchCount > 500) {
+      throw new Error("up to 500 translations can be saved at a time.");
+    }
+    await batch.commit();
   }
   /**
    * Returns the "key" used for a translation as stored in the db. Translations
@@ -822,6 +1315,25 @@ var RootCMSClient = class {
     const translationsMap = await this.loadTranslations(options);
     return translationsForLocale(translationsMap, locale);
   }
+  /**
+   * Firestore path for a translations file.
+   */
+  dbTranslationsPath(translationsId, options) {
+    const mode = options.mode;
+    if (!(mode === "draft" || mode === "published")) {
+      throw new Error(`invalid mode: ${mode}`);
+    }
+    const slug = translationsId.replaceAll("/", "--");
+    const dbPath = `Projects/${this.projectId}/TranslationsManager/${mode}/Translations/${slug}`;
+    return dbPath;
+  }
+  /**
+   * Firestore doc ref for a translations file.
+   */
+  dbTranslationsRef(translationsId, options) {
+    const dbPath = this.dbTranslationsPath(translationsId, options);
+    return this.db.doc(dbPath);
+  }
   /**
    * Returns a data source configuration object.
    */
@@ -852,7 +1364,7 @@ var RootCMSClient = class {
     const syncedBy = (options == null ? void 0 : options.syncedBy) || "root-cms-client";
     const updatedDataSource = {
       ...dataSource,
-      syncedAt: Timestamp2.now(),
+      syncedAt: Timestamp3.now(),
       syncedBy
     };
     const batch = this.db.batch();
@@ -861,7 +1373,7 @@ var RootCMSClient = class {
       data
     });
     batch.update(dataSourceDocRef, {
-      syncedAt: Timestamp2.now(),
+      syncedAt: Timestamp3.now(),
       syncedBy
     });
     await batch.commit();
@@ -886,25 +1398,64 @@ var RootCMSClient = class {
     const publishedBy = (options == null ? void 0 : options.publishedBy) || "root-cms-client";
     const updatedDataSource = {
       ...dataSource,
-      publishedAt: Timestamp2.now(),
+      publishedAt: Timestamp3.now(),
       publishedBy
     };
     const batch = this.db.batch();
     batch.set(dataDocRefPublished, {
       dataSource: updatedDataSource,
-      data: (dataRes == null ? void 0 : dataRes.data) || null
+      data: (dataRes == null ? void 0 : dataRes.data) || null,
+      ...(dataRes == null ? void 0 : dataRes.headers) ? { headers: dataRes.headers } : {}
     });
     batch.update(dataDocRefDraft, {
       dataSource: updatedDataSource
     });
     batch.update(dataSourceDocRef, {
-      publishedAt: Timestamp2.now(),
+      publishedAt: Timestamp3.now(),
       publishedBy
     });
     await batch.commit();
     console.log(`published data ${dataSourceId}`);
     console.log(`published by: ${publishedBy}`);
   }
+  async publishDataSources(dataSourceIds, options) {
+    const publishedBy = (options == null ? void 0 : options.publishedBy) || "root-cms-client";
+    const batch = (options == null ? void 0 : options.batch) || this.db.batch();
+    for (const id of dataSourceIds) {
+      const dataSource = await this.getDataSource(id);
+      if (!dataSource) {
+        throw new Error(`data source not found: ${id}`);
+      }
+      const dataSourceDocRef = this.db.doc(
+        `Projects/${this.projectId}/DataSources/${id}`
+      );
+      const dataDocRefDraft = this.db.doc(
+        `Projects/${this.projectId}/DataSources/${id}/draft`
+      );
+      const dataDocRefPublished = this.db.doc(
+        `Projects/${this.projectId}/DataSources/${id}/published`
+      );
+      const dataRes = await this.getFromDataSource(id, { mode: "draft" });
+      const updatedDataSource = {
+        ...dataSource,
+        publishedAt: FieldValue2.serverTimestamp(),
+        publishedBy
+      };
+      batch.set(dataDocRefPublished, {
+        dataSource: updatedDataSource,
+        data: (dataRes == null ? void 0 : dataRes.data) || null,
+        ...(dataRes == null ? void 0 : dataRes.headers) ? { headers: dataRes.headers } : {}
+      });
+      batch.update(dataDocRefDraft, { dataSource: updatedDataSource });
+      batch.update(dataSourceDocRef, {
+        publishedAt: FieldValue2.serverTimestamp(),
+        publishedBy
+      });
+    }
+    if (!(options == null ? void 0 : options.batch) || (options == null ? void 0 : options.commitBatch)) {
+      await batch.commit();
+    }
+  }
   async fetchData(dataSource) {
     if (dataSource.type === "http") {
       return await this.fetchHttpData(dataSource);
@@ -937,6 +1488,12 @@ var RootCMSClient = class {
    */
   async getFromDataSource(dataSourceId, options) {
     const mode = (options == null ? void 0 : options.mode) || "published";
+    if (!(mode === "draft" || mode === "published")) {
+      throw new Error(`invalid mode: ${mode}`);
+    }
+    if (!dataSourceId || dataSourceId.includes("/")) {
+      throw new Error(`invalid data source id: ${dataSourceId}`);
+    }
     const docRef = this.dbDataSourceDataRef(dataSourceId, { mode });
     const doc = await docRef.get();
     if (doc.exists) {
@@ -944,6 +1501,9 @@ var RootCMSClient = class {
     }
     return null;
   }
+  /**
+   * Firestore path for a datasource data.
+   */
   dbDataSourceDataPath(dataSourceId, options) {
     if (!dataSourceId || dataSourceId.includes("/")) {
       throw new Error(`invalid data source id: ${dataSourceId}`);
@@ -955,23 +1515,13 @@ var RootCMSClient = class {
     const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/${mode}`;
     return dbPath;
   }
+  /**
+   * Firestore doc ref for a datasource data.
+   */
   dbDataSourceDataRef(dataSourceId, options) {
     const dbPath = this.dbDataSourceDataPath(dataSourceId, options);
     return this.db.doc(dbPath);
   }
-  dbTranslationsPath(translationsId, options) {
-    const mode = options.mode;
-    if (!(mode === "draft" || mode === "published")) {
-      throw new Error(`invalid mode: ${mode}`);
-    }
-    const slug = translationsId.replaceAll("/", "--");
-    const dbPath = `Projects/${this.projectId}/TranslationsManager/${mode}/Translations/${slug}`;
-    return dbPath;
-  }
-  dbTranslationsRef(translationsId, options) {
-    const dbPath = this.dbTranslationsPath(translationsId, options);
-    return this.db.doc(dbPath);
-  }
   /**
    * Gets the user's role from the project's ACL.
    */
@@ -996,57 +1546,194 @@ var RootCMSClient = class {
     }
     return null;
   }
-  /**
-   * Verifies user exists in the ACL list.
-   */
-  async userExistsInAcl(email) {
-    if (!email) {
-      return false;
-    }
-    const docRef = this.db.doc(`Projects/${this.projectId}`);
-    const snapshot = await docRef.get();
-    const data = snapshot.data() || {};
-    const acl = data.roles || {};
-    if (email in acl) {
-      return true;
+  /**
+   * Verifies user exists in the ACL list.
+   */
+  async userExistsInAcl(email) {
+    if (!email) {
+      return false;
+    }
+    const docRef = this.db.doc(`Projects/${this.projectId}`);
+    const snapshot = await docRef.get();
+    const data = snapshot.data() || {};
+    const acl = data.roles || {};
+    if (email in acl) {
+      return true;
+    }
+    if (!email.includes("@")) {
+      console.warn(`invalid email: ${email}`);
+      return false;
+    }
+    const domain = email.split("@").at(-1);
+    if (domain && `*@${domain}` in acl) {
+      return true;
+    }
+    return false;
+  }
+  async logAction(action, options) {
+    if (!action) {
+      throw new Error('missing required: "action"');
+    }
+    const data = {
+      action,
+      timestamp: Timestamp3.now(),
+      by: (options == null ? void 0 : options.by) || "system",
+      metadata: (options == null ? void 0 : options.metadata) || {}
+    };
+    const colRef = this.db.collection(`Projects/${this.projectId}/ActionLogs`);
+    await colRef.add(data);
+    const metaStr = (options == null ? void 0 : options.metadata) ? stringifyObj(options.metadata) : "";
+    console.log(`[${data.timestamp.toMillis()}] action: ${action} ${metaStr}`);
+    const cmsPluginConfig = this.cmsPlugin.getConfig();
+    if (cmsPluginConfig.onAction) {
+      try {
+        cmsPluginConfig.onAction(data);
+      } catch (err) {
+        console.error(err);
+      }
+    }
+  }
+  /**
+   * Creates a batch request that is capable of fetching one or more docs,
+   * corresponding translations, and dataSources.
+   */
+  createBatchRequest(options) {
+    return new BatchRequest(this, options);
+  }
+};
+function isRichTextData(data) {
+  return Boolean(
+    isObject(data) && Array.isArray(data.blocks) && data.time && data.version
+  );
+}
+function getCmsPlugin(rootConfig) {
+  const plugins = rootConfig.plugins || [];
+  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
+  if (!plugin) {
+    throw new Error("could not find root-cms plugin config in root.config.ts");
+  }
+  return plugin;
+}
+function marshalData(data) {
+  if (isRichTextData(data)) {
+    return data;
+  }
+  const result = {};
+  for (const key in data) {
+    const val = data[key];
+    if (isObject(val)) {
+      result[key] = marshalData(val);
+    } else if (Array.isArray(val)) {
+      if (val.length > 0 && val.some((item) => isObject(item))) {
+        const items = val.map((item) => {
+          if (isObject(item)) {
+            return marshalData(item);
+          }
+          return item;
+        });
+        result[key] = toArrayObject(items);
+      } else {
+        result[key] = val;
+      }
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function unmarshalData(data) {
+  const result = {};
+  for (const key in data) {
+    const val = data[key];
+    if (isObject(val)) {
+      if (val.toMillis) {
+        result[key] = val.toMillis();
+      } else if (Object.hasOwn(val, "_array") && Array.isArray(val._array)) {
+        const arr = val._array.map((arrayKey) => {
+          return {
+            ...unmarshalData(val[arrayKey] || {}),
+            _arrayKey: arrayKey
+          };
+        });
+        result[key] = arr;
+      } else {
+        result[key] = unmarshalData(val);
+      }
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function toArrayObject(arr) {
+  if (!Array.isArray(arr)) {
+    return arr;
+  }
+  const arrObject = { _array: [] };
+  for (const item of arr) {
+    const key = randString(6);
+    arrObject[key] = item;
+    arrObject._array.push(key);
+  }
+  return arrObject;
+}
+function isObject(data) {
+  return typeof data === "object" && !Array.isArray(data) && data !== null;
+}
+function randString(len) {
+  const result = [];
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (let i = 0; i < len; i++) {
+    const rand = Math.floor(Math.random() * chars.length);
+    result.push(chars.charAt(rand));
+  }
+  return result.join("");
+}
+function translationsForLocale(translationsMap, locale) {
+  const localeTranslations = {};
+  Object.values(translationsMap).forEach((string) => {
+    const source = string.source;
+    const translation = string[locale] || string.en || string.source;
+    localeTranslations[source] = translation;
+  });
+  return localeTranslations;
+}
+function stringifyObj(obj) {
+  function format(obj2) {
+    if (obj2 === null) {
+      return "null";
     }
-    if (!email.includes("@")) {
-      console.warn(`invalid email: ${email}`);
-      return false;
+    if (typeof obj2 === "undefined") {
+      return "undefined";
     }
-    const domain = email.split("@").at(-1);
-    if (domain && `*@${domain}` in acl) {
-      return true;
+    if (typeof obj2 === "string") {
+      return `"${obj2.replaceAll('"', '\\"')}"`;
     }
-    return false;
-  }
-  async logAction(action, options) {
-    if (!action) {
-      throw new Error('missing required: "action"');
+    if (typeof obj2 !== "object") {
+      return String(obj2);
     }
-    const data = {
-      action,
-      timestamp: Timestamp2.now(),
-      by: (options == null ? void 0 : options.by) || "system",
-      metadata: (options == null ? void 0 : options.metadata) || {}
-    };
-    const colRef = this.db.collection(`Projects/${this.projectId}/ActionLogs`);
-    await colRef.add(data);
-    const metaStr = (options == null ? void 0 : options.metadata) ? stringifyObj(options.metadata) : "";
-    console.log(`[${data.timestamp.toMillis()}] action: ${action} ${metaStr}`);
-    const cmsPluginConfig = this.cmsPlugin.getConfig();
-    if (cmsPluginConfig.onAction) {
-      try {
-        cmsPluginConfig.onAction(data);
-      } catch (err) {
-        console.error(err);
-      }
+    if (Array.isArray(obj2)) {
+      return `[${obj2.map(format).join(", ")}]`;
     }
+    const entries = Object.entries(obj2).map(([key, value]) => {
+      return `${key}: ${format(value)}`;
+    });
+    return `{${entries.join(", ")}}`;
   }
-  createBatchRequest(options) {
-    return new BatchRequest(this, options);
+  return format(obj);
+}
+function parseDocId(docId) {
+  const sepIndex = docId.indexOf("/");
+  if (sepIndex <= 0) {
+    throw new Error(`invalid doc id: ${docId}`);
   }
-};
+  const collection = docId.slice(0, sepIndex);
+  const slug = docId.slice(sepIndex + 1).replaceAll("/", "--");
+  if (!collection || !slug) {
+    throw new Error(`invalid doc id: ${docId}`);
+  }
+  return { collection, slug };
+}
 var BatchRequest = class {
   constructor(cmsClient, options) {
     this.docIds = [];
@@ -1216,6 +1903,8 @@ var BatchResponse = class {
    * The input is either a single locale (e.g. "de") or an array of locales
    * representing the fallback tree, e.g. ["en-CA", "en-GB", "en"].
    *
+   * TODO(stevenle): support the locale fallback tree.
+   *
    * The returned value is a flat map of source string to translated string,
    * e.g.:
    * {"<source>": "<translation>"}
@@ -1249,145 +1938,10 @@ var BatchResponse = class {
     return translationsMap;
   }
 };
-function isRichTextData(data) {
-  return Boolean(
-    isObject(data) && Array.isArray(data.blocks) && data.time && data.version
-  );
-}
-function marshalData(data) {
-  if (isRichTextData(data)) {
-    return data;
-  }
-  const result = {};
-  for (const key in data) {
-    const val = data[key];
-    if (isObject(val)) {
-      result[key] = marshalData(val);
-    } else if (Array.isArray(val)) {
-      if (val.length > 0 && val.some((item) => isObject(item))) {
-        const items = val.map((item) => {
-          if (isObject(item)) {
-            return marshalData(item);
-          }
-          return item;
-        });
-        result[key] = toArrayObject(items);
-      } else {
-        result[key] = val;
-      }
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-function unmarshalData(data) {
-  const result = {};
-  for (const key in data) {
-    const val = data[key];
-    if (isObject(val)) {
-      if (val.toMillis) {
-        result[key] = val.toMillis();
-      } else if (Object.hasOwn(val, "_array") && Array.isArray(val._array)) {
-        const arr = val._array.map((arrayKey) => {
-          return {
-            ...unmarshalData(val[arrayKey] || {}),
-            _arrayKey: arrayKey
-          };
-        });
-        result[key] = arr;
-      } else {
-        result[key] = unmarshalData(val);
-      }
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-function toArrayObject(arr) {
-  if (!Array.isArray(arr)) {
-    return arr;
-  }
-  const arrObject = { _array: [] };
-  for (const item of arr) {
-    const key = randString(6);
-    arrObject[key] = item;
-    arrObject._array.push(key);
-  }
-  return arrObject;
-}
-function isObject(data) {
-  return typeof data === "object" && !Array.isArray(data) && data !== null;
-}
-function randString(len) {
-  const result = [];
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  for (let i = 0; i < len; i++) {
-    const rand = Math.floor(Math.random() * chars.length);
-    result.push(chars.charAt(rand));
-  }
-  return result.join("");
-}
-function translationsForLocale(translationsMap, locale) {
-  const localeTranslations = {};
-  const fallbackLocales = Array.isArray(locale) ? locale : [locale];
-  if (!fallbackLocales.includes("en")) {
-    fallbackLocales.push("en");
-  }
-  Object.values(translationsMap).forEach((string) => {
-    const source = string.source;
-    let translation = source;
-    for (const fallbackLocale of fallbackLocales) {
-      if (string[fallbackLocale]) {
-        translation = string[fallbackLocale];
-        break;
-      }
-    }
-    localeTranslations[source] = translation;
-  });
-  return localeTranslations;
-}
-function stringifyObj(obj) {
-  function format(obj2) {
-    if (obj2 === null) {
-      return "null";
-    }
-    if (typeof obj2 === "undefined") {
-      return "undefined";
-    }
-    if (typeof obj2 === "string") {
-      return `"${obj2.replaceAll('"', '\\"')}"`;
-    }
-    if (typeof obj2 !== "object") {
-      return String(obj2);
-    }
-    if (Array.isArray(obj2)) {
-      return `[${obj2.map(format).join(", ")}]`;
-    }
-    const entries = Object.entries(obj2).map(([key, value]) => {
-      return `${key}: ${format(value)}`;
-    });
-    return `{${entries.join(", ")}}`;
-  }
-  return format(obj);
-}
-function parseDocId(docId) {
-  const sepIndex = docId.indexOf("/");
-  if (sepIndex <= 0) {
-    throw new Error(`invalid doc id: ${docId}`);
-  }
-  const collection = docId.slice(0, sepIndex);
-  const slug = docId.slice(sepIndex + 1).replaceAll("/", "--");
-  if (!collection || !slug) {
-    throw new Error(`invalid doc id: ${docId}`);
-  }
-  return { collection, slug };
-}
 
 // core/versions.ts
 import path from "node:path";
-import { Timestamp as Timestamp3 } from "firebase-admin/firestore";
+import { Timestamp as Timestamp4 } from "firebase-admin/firestore";
 import glob from "tiny-glob";
 var DOCUMENT_SAVE_OFFSET = 5 * 60 * 1e3;
 var VersionsService = class {
@@ -1406,7 +1960,7 @@ var VersionsService = class {
     const lastRun = await this.getLastRun();
     const lastRunWithOffset = lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;
     const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);
-    const now = Timestamp3.now().toMillis();
+    const now = Timestamp4.now().toMillis();
     const versions = changedDocs.filter((doc) => {
       const modifiedAt = doc.sys.modifiedAt.toMillis();
       return modifiedAt <= now - DOCUMENT_SAVE_OFFSET;
@@ -1452,7 +2006,7 @@ var VersionsService = class {
    * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.
    */
   async saveLastRun(millis) {
-    const ts = Timestamp3.fromMillis(millis);
+    const ts = Timestamp4.fromMillis(millis);
     const projectDocRef = this.db.collection("Projects").doc(this.projectId);
     await projectDocRef.set({ versionsLastRun: ts }, { merge: true });
   }
@@ -1460,7 +2014,7 @@ var VersionsService = class {
    * Returns a list of all docs that were edited after a certain time.
    */
   async getDocsModifiedAfter(millis) {
-    const ts = Timestamp3.fromMillis(millis);
+    const ts = Timestamp4.fromMillis(millis);
     const results = [];
     const collectionIds = await this.listCollections();
     for (const collectionId of collectionIds) {
@@ -1534,7 +2088,31 @@ function csvToArray(csvString) {
 }
 
 // core/api.ts
-function api(server) {
+function api(server, options) {
+  server.use("/cms/api/collection.get", async (req, res) => {
+    if (req.method !== "POST" || !String(req.get("content-type")).startsWith("application/json")) {
+      res.status(400).json({ success: false, error: "BAD_REQUEST" });
+      return;
+    }
+    const reqBody = req.body || {};
+    if (!reqBody.collectionId) {
+      res.status(400).json({ success: false, error: "MISSING_COLLECTION_ID" });
+      return;
+    }
+    try {
+      const app = await options.getRenderer(req);
+      const collections = app.getCollections();
+      const collection = collections[reqBody.collectionId];
+      if (!collection) {
+        res.status(404).json({ success: false, error: "NOT_FOUND" });
+        return;
+      }
+      res.status(200).json({ success: true, data: collection });
+    } catch (err) {
+      console.error(err.stack || err);
+      res.status(500).json({ success: false, error: "UNKNOWN" });
+    }
+  });
   server.use("/cms/api/cron.run", async (req, res) => {
     try {
       await runCronJobs(req.rootConfig);
@@ -1692,102 +2270,15 @@ function api(server) {
   });
 }
 
-// core/compatibility.ts
-import { Timestamp as Timestamp4 } from "firebase-admin/firestore";
-async function runCompatibilityChecks(rootConfig) {
-  const cmsClient = new RootCMSClient(rootConfig);
-  const projectId = cmsClient.projectId;
-  const db = cmsClient.db;
-  const projectConfigDocRef = db.doc(`Projects/${projectId}`);
-  const projectConfigDoc = await projectConfigDocRef.get();
-  const projectConfig = projectConfigDoc.data() || {};
-  const compatibilityVersions = projectConfig.compatibility || {};
-  let versionsChanged = false;
-  const translationsVersion = compatibilityVersions.translations || 0;
-  if (translationsVersion < 2) {
-    await migrateTranslationsToV2(rootConfig, cmsClient);
-    compatibilityVersions.translations = 2;
-    versionsChanged = true;
-  }
-  if (versionsChanged) {
-    await projectConfigDocRef.update({ compatibility: compatibilityVersions });
-    console.log("[root cms] updated db compatibility");
-  }
-}
-async function migrateTranslationsToV2(rootConfig, cmsClient) {
-  var _a, _b;
-  if ((_a = rootConfig.experiments) == null ? void 0 : _a.rootCmsDisableTranslationsToV2Check) {
-    return;
-  }
-  const projectId = cmsClient.projectId;
-  const db = cmsClient.db;
-  const dbPath = `Projects/${projectId}/Translations`;
-  const query = db.collection(dbPath);
-  const querySnapshot = await query.get();
-  if (querySnapshot.size === 0) {
-    return;
-  }
-  console.log("[root cms] updating translations v2 compatibility");
-  const translationsDocs = {};
-  querySnapshot.forEach((doc) => {
-    const hash = doc.id;
-    const translation = doc.data();
-    const tags = translation.tags || [];
-    delete translation.tags;
-    for (const tag of tags) {
-      if (tag.includes("/")) {
-        const translationsId = tag.replaceAll("/", "--");
-        translationsDocs[translationsId] ??= {
-          id: translationsId,
-          sys: {
-            modifiedAt: Timestamp4.now(),
-            modifiedBy: "root-cms-client",
-            publishedAt: Timestamp4.now(),
-            publishedBy: "root-cms-client",
-            tags
-          },
-          strings: {}
-        };
-        translationsDocs[translationsId].strings[hash] = translation;
-      }
-    }
-  });
-  if (Object.keys(translationsDocs).length === 0) {
-    console.log("[root cms] no translations to save");
-    return;
-  }
-  for (const docId in translationsDocs) {
-    const [collection, slug] = docId.split("/");
-    if (collection && slug) {
-      const doc = await cmsClient.getDoc(collection, slug, {
-        mode: "draft"
-      });
-      const linkedSheet = (_b = doc == null ? void 0 : doc.sys) == null ? void 0 : _b.l10nSheet;
-      if (linkedSheet) {
-        translationsDocs[docId].sys.linkedSheet = linkedSheet;
-      }
-    }
-  }
-  const batch = db.batch();
-  Object.entries(translationsDocs).forEach(([translationsId, data]) => {
-    const draftRef = db.doc(
-      `Projects/${projectId}/TranslationsManager/draft/Translations/${translationsId}`
-    );
-    const publishedRef = db.doc(
-      `Projects/${projectId}/TranslationsManager/published/Translations/${translationsId}`
-    );
-    batch.set(draftRef, data, { merge: true });
-    batch.set(publishedRef, data, { merge: true });
-    const len = Object.keys(data.strings).length;
-    console.log(`[root cms] saving ${len} string(s) to ${translationsId}...`);
-  });
-  await batch.commit();
-  console.log("[root cms] done migrating translations to v2");
-}
-
 // core/plugin.ts
 var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
 var SESSION_COOKIE_AUTH = "root-cms-auth";
+var NONCONF_STATIC_PATHS = [
+  "/cms/static/signin.css",
+  "/cms/static/signin.js",
+  "/cms/static/ui.css",
+  "/cms/static/ui.js"
+];
 function isExpired(decodedIdToken) {
   const ts = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
   return ts >= decodedIdToken.exp;
@@ -1824,7 +2315,7 @@ function cmsPlugin(options) {
     if (urlPath === "/cms/api/cron.run") {
       return false;
     }
-    if (urlPath === "/cms/static/signin.css" || urlPath === "/cms/static/signin.js") {
+    if (NONCONF_STATIC_PATHS.includes(urlPath)) {
       return false;
     }
     if (urlPath.startsWith("/cms")) {
@@ -1988,17 +2479,6 @@ function cmsPlugin(options) {
     ssrInput: () => ({
       cms: path3.resolve(__dirname2, "./app.js")
     }),
-    hooks: {
-      /**
-       * Startup hook. On `dev` and `build` commands, the plugin does
-       * compatibility checks.
-       */
-      startup: async ({ command, rootConfig }) => {
-        if (command === "dev" || command === "build") {
-          await runCompatibilityChecks(rootConfig);
-        }
-      }
-    },
     /**
      * Attaches CMS-specific middleware to the Root.js server.
      */
@@ -2086,7 +2566,7 @@ function cmsPlugin(options) {
       });
       const staticDir = path3.resolve(__dirname2, "ui");
       server.use("/cms/static", sirv(staticDir, { dev: false }));
-      api(server);
+      api(server, { getRenderer });
       server.use("/cms", async (req, res) => {
         try {
           if (!req.user) {
@@ -2120,16 +2600,6 @@ function cmsPlugin(options) {
 function fileExists(filepath) {
   return fs2.access(filepath).then(() => true).catch(() => false);
 }
-function getCmsPlugin(rootConfig) {
-  const plugins = rootConfig.plugins || [];
-  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
-  if (!plugin) {
-    throw new Error("could not find root-cms plugin config in root.config.ts");
-  }
-  return plugin;
-}
 export {
-  cmsPlugin,
-  getCmsPlugin
+  cmsPlugin
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../cli/generate-types.ts", "../core/plugin.ts", "../core/api.ts", "../core/ai.ts", "../core/client.ts", "../core/versions.ts", "../core/cron.ts", "../core/csv.ts", "../core/compatibility.ts"],
  "sourcesContent": ["import {promises as fs} from 'node:fs';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport {loadRootConfig, viteSsrLoadModule} from '@blinkk/root/node';\nimport * as dom from 'dts-dom';\n\nimport {Field, Schema} from '../core/schema.js';\n\ntype ProjectModule = typeof import('../core/project.js');\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nexport async function generateTypes() {\n  const rootDir = process.cwd();\n  const rootConfig = await loadRootConfig(rootDir, {command: 'root-cms'});\n  const modulePath = path.resolve(__dirname, './project.js');\n  const project = (await viteSsrLoadModule(\n    rootConfig,\n    modulePath\n  )) as ProjectModule;\n  const schemas = project.getProjectSchemas();\n  const outputPath = path.resolve(rootDir, 'root-cms.d.ts');\n  await generateSchemaDts(outputPath, schemas);\n  console.log('saved root-cms.d.ts!');\n}\n\nconst TEMPLATE = `/** Root.js CMS types. This file is autogenerated. */\n\nexport interface RootCMSImage {\n  src: string;\n  width?: number;\n  height?: number;\n  alt?: string;\n}\n\nexport type RootCMSOneOf<T = any> = T & {\n  _type: string;\n};\n\nexport interface RootCMSRichTextBlock {\n  type: string;\n  data: any;\n}\n\nexport interface RootCMSRichText {\n  blocks: RootCMSRichTextBlock[];\n}\n\nexport interface RootCMSReference {\n  /** The id of the doc, e.g. \"Pages/foo-bar\". */\n  id: string;\n  /** The collection id of the doc, e.g. \"Pages\". */\n  collection: string;\n  /** The slug of the doc, e.g. \"foo-bar\". */\n  slug: string;\n}\n\nexport interface RootCMSDoc<Fields extends {}> {\n  /** The id of the doc, e.g. \"Pages/foo-bar\". */\n  id: string;\n  /** The collection id of the doc, e.g. \"Pages\". */\n  collection: string;\n  /** The slug of the doc, e.g. \"foo-bar\". */\n  slug: string;\n  /** System-level metadata. */\n  sys: {\n    createdAt: number;\n    createdBy: string;\n    modifiedAt: number;\n    modifiedBy: string;\n    firstPublishedAt?: number;\n    firstPublishedBy?: string;\n    publishedAt?: number;\n    publishedBy?: string;\n    locales?: string[];\n  };\n  /** User-entered field values from the CMS. */\n  fields?: Fields;\n}`;\n\n/**\n * Generates a root-cms.d.ts file from the .schema.ts files in the project.\n */\nexport async function generateSchemaDts(\n  outputPath: string,\n  schemas: Record<string, Schema>\n) {\n  const results = [TEMPLATE];\n  for (const fileId in schemas) {\n    const schema = schemas[fileId];\n    results.push(renderSchema(fileId, schema));\n  }\n  const output = results\n    .join('\\n\\n')\n    .replaceAll('/**  ', '/** ')\n    .replaceAll('  */', ' */')\n    .replace(/\\r\\n|\\r|\\n/g, '\\n');\n  await fs.writeFile(outputPath, output, 'utf-8');\n}\n\nfunction fieldProperty(field: Field): dom.PropertyDeclaration {\n  const prop = dom.create.property(\n    field.id!,\n    fieldType(field),\n    dom.DeclarationFlags.Optional\n  );\n  const jsdoc = [];\n  if (field.label) {\n    if (field.help) {\n      jsdoc.push(`${field.label}. ${field.help}`);\n    } else {\n      jsdoc.push(field.label);\n    }\n  }\n  if (field.deprecated) {\n    jsdoc.push('@deprecated');\n  }\n  if (jsdoc.length > 0) {\n    prop.jsDocComment = jsdoc.join('\\n');\n  }\n  return prop;\n}\n\nfunction fieldType(field: Field): dom.Type {\n  if (field.type === 'array') {\n    return dom.type.array(fieldType(field.of));\n  }\n  if (field.type === 'boolean') {\n    return dom.type.boolean;\n  }\n  if (field.type === 'date') {\n    return dom.type.string;\n  }\n  if (field.type === 'datetime') {\n    return dom.type.number;\n  }\n  if (field.type === 'image') {\n    const imageType = dom.create.namedTypeReference('RootCMSImage');\n    return imageType;\n  }\n  if (field.type === 'file') {\n    return dom.create.objectType([dom.create.property('src', dom.type.string)]);\n  }\n  if (field.type === 'multiselect') {\n    return dom.type.array(dom.type.string);\n  }\n  if (field.type === 'oneof') {\n    const oneofType = dom.create.namedTypeReference('RootCMSOneOf');\n    return oneofType;\n  }\n  if (field.type === 'reference') {\n    const referenceType = dom.create.namedTypeReference('RootCMSReference');\n    return referenceType;\n  }\n  if (field.type === 'richtext') {\n    const richtextType = dom.create.namedTypeReference('RootCMSRichText');\n    return richtextType;\n  }\n  if (field.type === 'select') {\n    return dom.type.string;\n  }\n  if (field.type === 'string') {\n    return dom.type.string;\n  }\n  if (field.type === 'object') {\n    const subproperties = (field.fields || []).map((f) => fieldProperty(f));\n    return dom.create.objectType(subproperties);\n  }\n  return dom.type.unknown;\n}\n\nfunction renderSchema(fileId: string, schema: Schema): string {\n  const jsdoc = `Generated from \\`${fileId}\\`.`;\n  const id = alphanumeric(path.parse(fileId).name.split('.')[0]);\n  const fieldsInterface = `${id}Fields`;\n  const fields = dom.create.interface(\n    fieldsInterface,\n    dom.DeclarationFlags.Export\n  );\n  fields.jsDocComment = jsdoc;\n  for (const field of schema.fields) {\n    if (!field.id) {\n      continue;\n    }\n    fields.members.push(fieldProperty(field));\n  }\n\n  const fieldsTypeOutput = dom\n    .emit(fields, {singleLineJsDocComments: true})\n    .trim();\n  if (fileId.startsWith('/collections/')) {\n    const baseType = dom.create.namedTypeReference('RootCMSDoc');\n    baseType.typeArguments.push(dom.create.namedTypeReference(fieldsInterface));\n    const docType = dom.create.alias(\n      `${id}Doc`,\n      baseType,\n      dom.DeclarationFlags.Export\n    );\n    docType.jsDocComment = jsdoc;\n\n    const docTypeOutput = dom\n      .emit(docType, {singleLineJsDocComments: true})\n      .trim();\n    return reindent(fieldsTypeOutput + '\\n\\n' + docTypeOutput);\n  }\n  return reindent(fieldsTypeOutput);\n}\n\n/**\n * Converts 4-space indents to 2.\n */\nfunction reindent(input: string): string {\n  const lines = input.split('\\n');\n  const results: string[] = [];\n  for (const line of lines) {\n    const convertedLine = line.replace(/ {4}/g, '  ');\n    results.push(convertedLine);\n  }\n  return results.join('\\n');\n}\n\n/**\n * Removes non-alphanumeric chars from a string.\n */\nfunction alphanumeric(input: string): string {\n  return input.replace(/[^a-zA-Z0-9]/g, '');\n}\n", "import {promises as fs} from 'node:fs';\nimport path from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport type {\n  ConfigureServerOptions,\n  NextFunction,\n  Plugin,\n  Request,\n  Response,\n  RootConfig,\n  Server,\n} from '@blinkk/root';\nimport bodyParser from 'body-parser';\nimport {\n  App,\n  applicationDefault,\n  getApp,\n  initializeApp,\n} from 'firebase-admin/app';\nimport {getAuth, DecodedIdToken} from 'firebase-admin/auth';\nimport {Firestore, getFirestore} from 'firebase-admin/firestore';\nimport * as jsonwebtoken from 'jsonwebtoken';\nimport sirv from 'sirv';\nimport {api} from './api.js';\nimport {Action, RootCMSClient} from './client.js';\nimport {runCompatibilityChecks} from './compatibility.js';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\ntype AppModule = typeof import('./app.js');\n\n// The session key name used for Root CMS authentication.\nconst SESSION_COOKIE_AUTH = 'root-cms-auth';\n\nexport interface CMSUser {\n  email: string;\n}\n\nexport interface CMSAIConfig {\n  /** Custom API endpoint for chat prompts. */\n  endpoint?: string;\n  /** Gen AI model to use. Defaults to 'gemini-1.5-flash'. */\n  model?: 'gemini-1.5-flash' | 'gemini-1.5-pro';\n}\n\nexport interface CMSSidebarTool {\n  /** URL for the sidebar icon image. */\n  icon?: string;\n  /** Label. */\n  label?: string;\n  /** Iframe URL to render for the tool. */\n  iframeUrl?: string;\n}\n\nexport type CMSPluginOptions = {\n  /**\n   * The ID of the project. Data will be stored under the namespace\n   * `Projects/${id}` in firestore.\n   */\n  id?: string;\n\n  /**\n   * The name of the project. Used in the header of the CMS to help identify\n   * the project.\n   */\n  name?: string;\n\n  /**\n   * Firebase config object, which can be obtained in the Firebase Console by\n   * going to \"Project Settings\".\n   */\n  firebaseConfig: {\n    [key: string]: string | undefined;\n    apiKey: string;\n    authDomain: string;\n    projectId: string;\n    storageBucket: string;\n    databaseId?: string;\n  };\n\n  /**\n   * GAPI credentials. Include if using Google Drive and Google Sheets features.\n   * See: https://developers.google.com/sheets/api/quickstart/js\n   */\n  gapi?: {\n    /** https://developers.google.com/sheets/api/quickstart/js#create_an_api_key */\n    apiKey: string;\n    /** https://developers.google.com/sheets/api/quickstart/js#authorize_credentials_for_a_web_application */\n    clientId: string;\n  };\n\n  /**\n   * Secret value(s) used for signing the user authentication cookie.\n   * @deprecated This is now handled directly by root's sessionMiddleware under\n   * `server.sessionCookieSecret` in root.config.ts.\n   */\n  cookieSecret?: string | string[];\n\n  /** Function called to check if a user should have access to the CMS. */\n  isUserAuthorized?: (\n    req: Request,\n    user: CMSUser\n  ) => boolean | Promise<boolean>;\n\n  /**\n   * Function to call to check if login is required for a particular request.\n   */\n  isLoginRequired?: (req: Request) => boolean;\n\n  /**\n   * By default, iframing the CMS is disallowed. Setting this value will allow\n   * iframes from the specified origins. Example:\n   * ```\n   * allowedIframeOrigins: ['https://app.example.com']\n   * ```\n   */\n  allowedIframeOrigins?: string[];\n\n  /**\n   * URL to GCI service for transforming uploaded GCS images to a Google App\n   * Engine Images API serving URL.\n   *\n   * Setting this to `true` uses the default hosted service at\n   * https://gci.rootjs.dev.\n   *\n   * To set up GCI:\n   *\n   * - Create a GCS bucket with fine-grained permissions\n   * - Share owner access to the bucket with the service account returned in\n   *   https://gci.rootjs.dev/_/service_account\n   *\n   * To disable GCI, leave this value empty or set to `false`, which which will\n   * serve images directly from GCS instead.\n   */\n  gci?: string | boolean;\n\n  /**\n   * Customization options for the CMS sidebar.\n   */\n  sidebar?: {\n    /**\n     * Sidebar tools, a map of the sidebar id to config options. The sidebar\n     * tool is url-mapped to `/cms/tools/:id` and displays the tool in an\n     * iframe.\n     */\n    tools?: Record<string, CMSSidebarTool>;\n  };\n\n  /**\n   * Callback when an action occurs.\n   */\n  onAction?: (action: Action) => any;\n\n  /**\n   * Experimental config options. Note: these are subject to change at any time.\n   */\n  experiments?: {\n    ai?: boolean | CMSAIConfig;\n  };\n\n  /**\n   * Adjust console output verbosity. Default is `'info'`.\n   */\n  logLevel?: 'info' | 'warn' | 'error' | 'silent' | 'debug';\n\n  /**\n   * Whether to enable/disable file watching in dev (e.g. for generating\n   * `root-cms.d.ts`). Defaults to `true`.\n   */\n  watch?: boolean;\n};\n\nexport type CMSPlugin = Plugin & {\n  name: 'root-cms';\n  getConfig: () => CMSPluginOptions;\n  getFirebaseApp: () => App;\n  getFirestore: () => Firestore;\n};\n\nfunction isExpired(decodedIdToken: DecodedIdToken) {\n  const ts = Math.floor(new Date().getTime() / 1000);\n  return ts >= decodedIdToken.exp;\n}\n\nfunction getFirebaseApp(gcpProjectId: string): App {\n  const appName = 'root-cms';\n  try {\n    return getApp(appName);\n  } catch (err) {\n    if (err && err.code === 'app/no-app') {\n      return initializeApp(\n        {\n          projectId: gcpProjectId,\n          credential: applicationDefault(),\n        },\n        appName\n      );\n    }\n    throw err;\n  }\n}\n\nexport function cmsPlugin(options: CMSPluginOptions): CMSPlugin {\n  const logLevel = options.logLevel || 'info';\n\n  if (!options.firebaseConfig) {\n    throw new Error(\n      'missing firebaseConfig. create a new app in the firebase admin console and copy the firebase config object to root.config.ts'\n    );\n  }\n\n  const firebaseConfig = options.firebaseConfig || {};\n  const app = getFirebaseApp(firebaseConfig.projectId);\n  const auth = getAuth(app);\n\n  /**\n   * Checks if login is required for the request. Currently returns `true` if\n   * the URL path starts with /cms or if ?preview=true is in the URL.\n   */\n  function loginRequired(req: Request): boolean {\n    const urlPath = String(req.originalUrl).split('?')[0].toLowerCase();\n    // Allow the cron to run unauthenticated. The cron job is responsible\n    // for saving version history.\n    if (urlPath === '/cms/api/cron.run') {\n      return false;\n    }\n    // Allow the signin.css and signin.js files to be rendered without auth.\n    if (\n      urlPath === '/cms/static/signin.css' ||\n      urlPath === '/cms/static/signin.js'\n    ) {\n      return false;\n    }\n    // Require login on all `/cms/` paths.\n    if (urlPath.startsWith('/cms')) {\n      return true;\n    }\n    // Require login on all paths that have `?preview=true`, which is used by\n    // the preview iframe to render the preview for a page.\n    if (String(req.query.preview) === 'true') {\n      return true;\n    }\n    if (options.isLoginRequired && options.isLoginRequired(req)) {\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Verifies a new login request for a user. The request body should contain\n   * an idToken, which is verified on prod using Firebase Admin and Identity\n   * Toolkit. If a `isUserAuthorized()` config is set, this function will also\n   * verify via that function. Returns true if the login verification succeeds.\n   */\n  async function verifyUserLogin(\n    req: Request\n  ): Promise<{authorized: boolean; reason?: string}> {\n    const idToken = req.body?.idToken;\n    if (!idToken) {\n      console.log('login failed: no id token');\n      return {authorized: false, reason: 'no token'};\n    }\n\n    let user: CMSUser;\n\n    // On local dev, simply verify the decoded idToken's email is set. The\n    // identity toolkit that verifies id tokens requires a service account,\n    // which we want to avoid having to set up when users are doing local dev.\n    // Authentication is still required by the frontend using Firebase Auth,\n    // this just bypasses the initial server check before the ui is rendered.\n    try {\n      if (process.env.NODE_ENV === 'development') {\n        const jwt = jsonwebtoken.decode(idToken) as jsonwebtoken.JwtPayload;\n        if (!jwt.email || !jwt.email_verified) {\n          console.log('login failed: email unverified');\n          return {authorized: false, reason: 'login failed'};\n        }\n        user = {email: jwt.email};\n      } else {\n        const jwt = await auth.verifyIdToken(idToken, true);\n        if (isExpired(jwt)) {\n          console.log('login failed: id token is expired');\n          return {authorized: false, reason: 'login failed'};\n        }\n        if (!jwt.email || !jwt.email_verified) {\n          console.log('login failed: email unverified');\n          return {authorized: false, reason: 'login failed'};\n        }\n        user = {email: jwt.email};\n      }\n\n      // Verify the project's `isUserAuthorized()` config option.\n      if (options.isUserAuthorized) {\n        const authorized = await options.isUserAuthorized(req, {\n          email: user.email,\n        });\n        if (!authorized) {\n          console.log('login failed: user is not authorized');\n          return {authorized: false, reason: 'not authorized'};\n        }\n      }\n\n      // Verify the user exists in the DB's ACL list.\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const userHasAccess = await cmsClient.userExistsInAcl(user.email);\n      if (!userHasAccess) {\n        console.log('login failed: user is not in the firestore acl list');\n        return {authorized: false, reason: 'not authorized'};\n      }\n    } catch (err) {\n      console.error('failed to verify jwt token');\n      console.error(err);\n      return {authorized: false, reason: 'unknown error'};\n    }\n\n    return {authorized: true};\n  }\n\n  /**\n   * Returns the current user based on the request's session cookie. The\n   * session cookie is checked for validity through Firebase Auth and the user's\n   * email is verified to have access to Root CMS, otherwise returns `null`.\n   */\n  async function getCurrentUser(req: Request): Promise<CMSUser | null> {\n    const sessionCookie = req.session.getItem(SESSION_COOKIE_AUTH);\n    if (!sessionCookie) {\n      if (logLevel === 'debug') {\n        console.log('no login session cookie');\n      }\n      return null;\n    }\n\n    // On local dev, verify the decoded idToken has a valid email. The firebase\n    // auth verification otherwise would require a service account.\n    if (process.env.NODE_ENV === 'development') {\n      const jwt = jsonwebtoken.decode(sessionCookie) as jsonwebtoken.JwtPayload;\n      if (!jwt?.email || !jwt?.email_verified) {\n        return null;\n      }\n      // Check whether user is authorized.\n      if (options.isUserAuthorized) {\n        const authorized = await options.isUserAuthorized(req, {\n          email: jwt.email,\n        });\n        if (!authorized) {\n          console.log('session failed: not authorized');\n          return null;\n        }\n      }\n      // Verify the user exists in the DB's ACL list.\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const userHasAccess = await cmsClient.userExistsInAcl(jwt.email);\n      if (!userHasAccess) {\n        console.log('session failed: user is not in the firestore acl list');\n        return null;\n      }\n      return {email: jwt.email};\n    }\n\n    try {\n      // Verify the idToken using firebase auth, checking for token revocations.\n      const jwt = await auth.verifySessionCookie(sessionCookie, true);\n      if (isExpired(jwt)) {\n        console.log('session failed: token is expired');\n        return null;\n      }\n      // Verify user's email is verified.\n      if (!jwt.email || !jwt.email_verified) {\n        console.log('session failed: email not verified');\n        return null;\n      }\n      // Check whether user is authorized.\n      if (options.isUserAuthorized) {\n        const authorized = await options.isUserAuthorized(req, {\n          email: jwt.email!,\n        });\n        if (!authorized) {\n          console.log('session failed: not authorized');\n          return null;\n        }\n      }\n      // Verify the user exists in the DB's ACL list.\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const userHasAccess = await cmsClient.userExistsInAcl(jwt.email);\n      if (!userHasAccess) {\n        console.log('session failed: user is not in the firestore acl list');\n        return null;\n      }\n      // JWT verified.\n      return {email: jwt.email!};\n    } catch (err) {\n      console.error('failed to verify jwt token');\n      console.error(err);\n      return null;\n    }\n  }\n\n  function redirectToLogin(req: Request, res: Response) {\n    if (String(req.originalUrl).toLowerCase().startsWith('/cms/api')) {\n      res.status(401).json({success: false, error: 'NOT_AUTHORIZED'});\n      return;\n    }\n    console.log('redirecting to login page');\n    const params = new URLSearchParams({\n      continue: req.originalUrl,\n    });\n    res.redirect(`/cms/login?${params.toString()}`);\n  }\n\n  const plugin: CMSPlugin = {\n    name: 'root-cms',\n\n    /**\n     * Returns the config options passed to the plugin.\n     */\n    getConfig: () => {\n      return options;\n    },\n\n    /**\n     * Returns the Firebase App instance used by the plugin.\n     */\n    getFirebaseApp: () => {\n      return app;\n    },\n\n    /**\n     * Returns the Firestore instance used by the plugin.\n     */\n    getFirestore: () => {\n      const databaseId = firebaseConfig.databaseId || '(default)';\n      return getFirestore(app, databaseId);\n    },\n\n    /**\n     * A map of ssr files to include when running `root build`.\n     */\n    ssrInput: () => ({\n      cms: path.resolve(__dirname, './app.js'),\n    }),\n\n    hooks: {\n      /**\n       * Startup hook. On `dev` and `build` commands, the plugin does\n       * compatibility checks.\n       */\n      startup: async ({command, rootConfig}) => {\n        if (command === 'dev' || command === 'build') {\n          await runCompatibilityChecks(rootConfig);\n        }\n      },\n    },\n\n    /**\n     * Attaches CMS-specific middleware to the Root.js server.\n     */\n    configureServer: async (\n      server: Server,\n      serverOptions: ConfigureServerOptions\n    ) => {\n      server.use(bodyParser.json());\n\n      async function getRenderer(req: Request): Promise<AppModule> {\n        if (serverOptions.type === 'dev') {\n          const appFilePath = path.resolve(__dirname, './app.js');\n          const app = (await req.viteServer!.ssrLoadModule(\n            appFilePath\n          )) as AppModule;\n          return app;\n        }\n\n        const appImportPath = path.resolve(\n          req.rootConfig!.rootDir,\n          'dist/server/cms.js'\n        );\n        if (!(await fileExists(appImportPath))) {\n          throw new Error(\n            'dist/server/cms.js not found. run `root build` to create it.'\n          );\n        }\n        const app = (await import(appImportPath)) as AppModule;\n        return app;\n      }\n\n      // Login handler.\n      server.use('/cms/login', async (req: Request, res: Response) => {\n        if (\n          req.method === 'PUT' &&\n          req.headers['content-type'] === 'application/json'\n        ) {\n          try {\n            const {authorized, reason} = await verifyUserLogin(req);\n            if (!authorized) {\n              res\n                .status(401)\n                .json({success: false, error: 'NOT_AUTHORIZED', reason});\n              return;\n            }\n\n            // Set session expiration to 5 days.\n            const expiresIn = 60 * 60 * 24 * 5 * 1000;\n            const idToken = req.body.idToken!;\n\n            let sessionCookie: string;\n            if (process.env.NODE_ENV === 'development') {\n              sessionCookie = idToken;\n            } else {\n              sessionCookie = await auth.createSessionCookie(idToken, {\n                expiresIn,\n              });\n            }\n            res.session.setItem(SESSION_COOKIE_AUTH, sessionCookie);\n            res.saveSession();\n            res.json({success: true});\n          } catch (err) {\n            console.error(err);\n            if (err.stack) {\n              console.error(err.stack);\n            }\n            res\n              .status(500)\n              .json({success: false, error: 'UNKNOWN_SERVER_ERROR'});\n          }\n          return;\n        }\n\n        try {\n          const app = await getRenderer(req);\n          app.renderSignIn(req, res, {\n            rootConfig: req.rootConfig!,\n            cmsConfig: options,\n          });\n        } catch (err) {\n          console.error(err);\n          if (err.stack) {\n            console.error(err.stack);\n          }\n          res.status(500).send('UNKNOWN SERVER ERROR');\n        }\n      });\n\n      // Logout handler.\n      server.use('/cms/logout', async (req: Request, res: Response) => {\n        res.session.removeItem(SESSION_COOKIE_AUTH);\n        res.saveSession();\n        res.redirect('/cms/login');\n      });\n\n      // Inject the current user into the req object and check if login is\n      // required, sending unauthenticated users to the login page.\n      server.use(async (req: Request, res: Response, next: NextFunction) => {\n        const user = await getCurrentUser(req);\n        if (user) {\n          req.user = user;\n        }\n\n        // If no user and login is required for the given path, redirect to the\n        // login page.\n        if (!user && loginRequired(req)) {\n          redirectToLogin(req, res);\n          return;\n        }\n\n        next();\n      });\n\n      const staticDir = path.resolve(__dirname, 'ui');\n      server.use('/cms/static', sirv(staticDir, {dev: false}));\n\n      // Register API handlers.\n      api(server);\n\n      // Render the CMS SPA.\n      server.use('/cms', async (req: Request, res: Response) => {\n        try {\n          // Enforce login for all CMS paths. The `req.user` would only be\n          // populated if the firebase auth token is valid and the user has\n          // access via the Root CMS sharebox.\n          if (!req.user) {\n            redirectToLogin(req, res);\n            return;\n          }\n          const app = await getRenderer(req);\n          await app.renderApp(req, res, {\n            rootConfig: req.rootConfig!,\n            cmsConfig: options,\n          });\n        } catch (err) {\n          // TODO(stevenle): render a custom error page.\n          console.error(err);\n          res.status(500).send('UNKNOWN SERVER ERROR');\n        }\n      });\n    },\n  };\n\n  if (options.watch !== false) {\n    plugin.onFileChange = (\n      eventName: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',\n      filepath: string\n    ) => {\n      if (filepath.endsWith('.schema.ts')) {\n        // Avoid loading the `generate-types.js` module if it is not needed.\n        // See: https://github.com/blinkk/rootjs/issues/426\n        import('../cli/generate-types.js').then((generateTypesModule) => {\n          const generateTypes = generateTypesModule.generateTypes;\n          generateTypes();\n        });\n      }\n    };\n  }\n\n  return plugin;\n}\n\nfunction fileExists(filepath: string): Promise<boolean> {\n  return fs\n    .access(filepath)\n    .then(() => true)\n    .catch(() => false);\n}\n\nexport function getCmsPlugin(rootConfig: RootConfig): CMSPlugin {\n  const plugins: Plugin[] = rootConfig.plugins || [];\n  const plugin = plugins.find((plugin) => plugin.name === 'root-cms');\n  if (!plugin) {\n    throw new Error('could not find root-cms plugin config in root.config.ts');\n  }\n  return plugin as CMSPlugin;\n}\n", "import {Server, Request, Response} from '@blinkk/root';\nimport {multipartMiddleware} from '@blinkk/root/middleware';\nimport {Chat, ChatClient} from './ai.js';\nimport {RootCMSClient} from './client.js';\nimport {runCronJobs} from './cron.js';\nimport {arrayToCsv, csvToArray} from './csv.js';\n\n/**\n * Registers API middleware handlers.\n */\nexport function api(server: Server) {\n  /**\n   * Runs CMS cron jobs.\n   */\n  server.use('/cms/api/cron.run', async (req: Request, res: Response) => {\n    try {\n      await runCronJobs(req.rootConfig!);\n      res.status(200).json({success: true});\n    } catch (err) {\n      console.error(err);\n      res.status(500).json({success: false});\n    }\n  });\n\n  /**\n   * Accepts a JSON object containing {headers: [...], rows: [...]} and sends\n   * an HTTP response with a corresponding CSV file as an attachment.\n   *\n   * Sample request:\n   *\n   * ```json\n   * {\n   *   \"headers\": [\"foo\"],\n   *   \"rows\": [\n   *     {\"foo\": \"bar\"},\n   *     {\"foo\": \"baz\"},\n   *   ]\n   * }\n   * ```\n   */\n  server.use('/cms/api/csv.download', (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n\n    try {\n      const body = req.body || {};\n      const headers = body.headers || [];\n      const rows = body.rows || [];\n      const csv = arrayToCsv({headers, rows});\n      res.setHeader('Content-Type', 'text/csv');\n      res.setHeader('Content-Disposition', 'attachment; filename=\"data.csv\"');\n      res.status(200).end(csv);\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  /**\n   * Imports a CSV file and returns a JSON array of objects representing the\n   * CSV.\n   *\n   * Sample response:\n   *\n   * ```json\n   * {\n   *   \"success\": true,\n   *   \"data\": [\n   *     {\"foo\": \"bar\"},\n   *     {\"foo\": \"baz\"},\n   *   ]\n   * }\n   * ```\n   */\n  server.use(\n    '/cms/api/csv.import',\n    multipartMiddleware(),\n    (req: Request, res: Response) => {\n      if (req.method !== 'POST' || !req.files || !req.files.file) {\n        res.status(400).json({success: false, error: 'BAD_REQUEST'});\n        return;\n      }\n\n      try {\n        const file = req.files.file;\n        const csvString = file.buffer.toString('utf8');\n        const rows = csvToArray(csvString);\n        res.status(200).json({success: true, data: rows});\n      } catch (err) {\n        console.error(err.stack || err);\n        res.status(500).json({success: false, error: 'UNKNOWN'});\n      }\n    }\n  );\n\n  /**\n   * Runs a data source sync.\n   */\n  server.use('/cms/api/data.sync', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n    }\n\n    const reqBody = req.body || {};\n    const dataSourceId = reqBody.id;\n    if (!dataSourceId) {\n      res.status(400).json({success: false, error: 'MISSING_ID'});\n      return;\n    }\n    const cmsClient = new RootCMSClient(req.rootConfig!);\n    try {\n      await cmsClient.syncDataSource(dataSourceId, {syncedBy: req.user.email});\n      res.status(200).json({success: true, id: dataSourceId});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  /**\n   * Logs an action.\n   */\n  server.use('/cms/api/actions.log', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n    }\n\n    const reqBody = req.body || {};\n    const action = reqBody.action;\n    if (!action) {\n      res.status(400).json({\n        success: false,\n        error: 'MISSING_REQUIRED_FIELD',\n        field: 'action',\n      });\n    }\n    const metadata = reqBody.metadata || {};\n\n    const cmsClient = new RootCMSClient(req.rootConfig!);\n    try {\n      await cmsClient.logAction(action, {\n        by: req.user?.email,\n        metadata: metadata,\n      });\n      res.status(200).json({success: true});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  /**\n   * AI chatbot.\n   */\n  server.use('/cms/api/ai.chat', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n      return;\n    }\n    const reqBody = req.body || {};\n    if (!reqBody.prompt) {\n      res.status(400).json({success: false, error: 'MISSING_PROMPT'});\n      return;\n    }\n    const prompt = reqBody.prompt;\n\n    try {\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const chatClient = new ChatClient(cmsClient, req.user.email);\n      let chat: Chat;\n      if (reqBody.chatId) {\n        chat = await chatClient.getChat(reqBody.chatId);\n      } else {\n        chat = await chatClient.createChat();\n      }\n      const chatResponse = await chat.sendPrompt(prompt);\n      res\n        .status(200)\n        .json({success: true, chatId: chat.id, response: chatResponse});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n\n  server.use('/cms/api/ai.list_chats', async (req: Request, res: Response) => {\n    if (\n      req.method !== 'POST' ||\n      !String(req.get('content-type')).startsWith('application/json')\n    ) {\n      res.status(400).json({success: false, error: 'BAD_REQUEST'});\n      return;\n    }\n    if (!req.user?.email) {\n      res.status(401).json({success: false, error: 'UNAUTHORIZED'});\n      return;\n    }\n    const reqBody = req.body || {};\n    const limit = reqBody.limit;\n\n    try {\n      const cmsClient = new RootCMSClient(req.rootConfig!);\n      const chatClient = new ChatClient(cmsClient, req.user.email);\n      const chats = await chatClient.listChats({limit});\n      res.status(200).json({success: true, chats});\n    } catch (err) {\n      console.error(err.stack || err);\n      res.status(500).json({success: false, error: 'UNKNOWN'});\n    }\n  });\n}\n", "import crypto from 'node:crypto';\nimport {generate} from '@genkit-ai/ai';\nimport {configureGenkit} from '@genkit-ai/core';\nimport {vertexAI} from '@genkit-ai/vertexai';\nimport {gemini15ProPreview, gemini15FlashPreview} from '@genkit-ai/vertexai';\nimport {Timestamp} from 'firebase-admin/firestore';\nimport {RootCMSClient} from './client.js';\nimport {CMSPluginOptions} from './plugin.js';\n\nlet genkitIsConfigured = false;\n\ninterface ChatPrompt {\n  text?: string;\n  media?: {\n    url: string;\n    contentType: string;\n  };\n}\n\nexport class Chat {\n  chatClient: ChatClient;\n  cmsClient: RootCMSClient;\n  cmsPluginOptions: CMSPluginOptions;\n  id: string;\n  history?: any;\n  model?: string;\n\n  constructor(\n    chatClient: ChatClient,\n    id: string,\n    options?: {history?: any; model?: string}\n  ) {\n    this.chatClient = chatClient;\n    this.cmsClient = chatClient.cmsClient;\n    this.cmsPluginOptions = this.cmsClient.cmsPlugin.getConfig();\n    this.id = id;\n    this.history = options?.history;\n    this.model = options?.model;\n    if (!this.model) {\n      if (typeof this.cmsPluginOptions.experiments?.ai === 'object') {\n        if (this.cmsPluginOptions.experiments.ai.model) {\n          this.model = this.cmsPluginOptions.experiments.ai.model;\n        }\n      }\n    }\n  }\n\n  async sendPrompt(prompt: string | ChatPrompt | ChatPrompt[]): Promise<any> {\n    if (!genkitIsConfigured) {\n      const firebaseConfig = this.cmsPluginOptions.firebaseConfig;\n      configureGenkit({\n        plugins: [\n          vertexAI({\n            projectId: firebaseConfig.projectId,\n            // TODO(stevenle): figure out where to get this.\n            location: firebaseConfig.location || 'us-central1',\n          }),\n        ],\n      });\n      genkitIsConfigured = true;\n    }\n\n    let model = gemini15FlashPreview;\n    if (this.model === 'gemini-1.5-pro') {\n      model = gemini15ProPreview;\n    }\n\n    if (!this.history) {\n      // Seed the AI with information.\n      await this.initHistory();\n    }\n\n    // console.log('prompt:', prompt);\n    // if (this.history) {\n    //   console.log('history:', this.history);\n    // }\n    const res = await generate({\n      model: model,\n      prompt: prompt as any,\n      history: this.history,\n    });\n    console.log(res.text());\n    const history = res.toHistory();\n    this.history = history;\n    await this.dbDoc().update({history, modifiedAt: Timestamp.now()});\n    return res.text();\n  }\n\n  dbDoc() {\n    return this.chatClient.dbCollection().doc(this.id);\n  }\n\n  async initHistory() {\n    const systemText = [\n      `You are an assistant for a headless CMS called Root CMS which is used on a website called ${\n        this.cmsPluginOptions.name || this.cmsPluginOptions.id\n      }. Your job is to answer questions about the docs in the system, and if requested, help suggest changes to the JSON data in the docs. If you don't know the answer, just say that you don't know, don't try to make up an answer. Be friendly and playful with your messaging.`,\n      '',\n      'Here is the root.config.ts file for the site:',\n      '```',\n      JSON.stringify(this.cmsClient.rootConfig, null, 2),\n      '```',\n      '',\n      'Here are the docs that exist in the system:',\n    ];\n\n    // TODO(stevenle): read from all the collections in the system.\n    const pages = await this.cmsClient.listDocs('Pages', {mode: 'draft'});\n    pages.docs.forEach((doc: any) => {\n      systemText.push(JSON.stringify(doc));\n    });\n\n    this.history = [{role: 'system', content: [{text: systemText.join('\\n')}]}];\n    console.log(this.history);\n  }\n}\n\nexport class ChatClient {\n  cmsClient: RootCMSClient;\n  user: string;\n\n  constructor(cmsClient: RootCMSClient, user: string) {\n    this.cmsClient = cmsClient;\n    this.user = user;\n  }\n\n  async createChat(options?: {model?: string}): Promise<Chat> {\n    const chatId = crypto.randomUUID();\n    // Save chat to db so that user has a chat history and can enable \"sharing\"\n    // with others. Store the model used with the metadata.\n    const docRef = this.dbCollection().doc(chatId);\n    await docRef.set({\n      id: chatId,\n      createdBy: this.user,\n      createdAt: Timestamp.now(),\n      modifiedAt: Timestamp.now(),\n      model: options?.model || 'gemini-1.5-flash',\n    });\n    return new Chat(this, chatId);\n  }\n\n  async getChat(chatId: string): Promise<Chat> {\n    // Fetch chat from db to preserve the conversation's history.\n    const docRef = this.dbCollection().doc(chatId);\n    const chatDoc = await docRef.get();\n    if (!chatDoc.exists) {\n      throw new Error(`${chatId} does not exist`);\n    }\n    const chatData = chatDoc.data() || {};\n    return new Chat(this, chatId, {\n      history: chatData.history,\n      model: chatData.model,\n    });\n  }\n\n  async listChats(options?: {limit?: number}): Promise<any[]> {\n    const limit = options?.limit || 20;\n    const query = this.dbCollection()\n      .where('createdBy', '==', this.user)\n      .limit(limit)\n      .orderBy('createdAt', 'desc');\n    const res = await query.get();\n    return res.docs.map((doc) => doc.data());\n  }\n\n  dbCollection() {\n    return this.cmsClient.db.collection(\n      `Projects/${this.cmsClient.projectId}/Experiments/ai/Chat`\n    );\n  }\n}\n", "import crypto from 'node:crypto';\nimport type {RootConfig} from '@blinkk/root';\nimport {App} from 'firebase-admin/app';\nimport {\n  FieldValue,\n  Firestore,\n  Query,\n  Timestamp,\n  WriteBatch,\n} from 'firebase-admin/firestore';\nimport {CMSPlugin, getCmsPlugin} from './plugin.js';\n\nexport interface Doc<Fields = any> {\n  /** The id of the doc, e.g. \"Pages/foo-bar\". */\n  id: string;\n  /** The collection id of the doc, e.g. \"Pages\". */\n  collection: string;\n  /** The slug of the doc, e.g. \"foo-bar\". */\n  slug: string;\n  sys: {\n    createdAt: number;\n    createdBy: string;\n    modifiedAt: number;\n    modifiedBy: string;\n    firstPublishedAt?: number;\n    firstPublishedBy?: string;\n    publishedAt?: number;\n    publishedBy?: string;\n    publishingLocked: {\n      lockedAt: string;\n      lockedBy: string;\n      reason: string;\n      until?: Timestamp;\n    };\n    locales?: string[];\n  };\n  fields: Fields;\n}\n\nexport interface TranslationsDoc {\n  id: string;\n  sys: {\n    modifiedAt: Timestamp;\n    modifiedBy: string;\n    publishedAt?: Timestamp;\n    publishedBy?: string;\n    linkedSheet?: {\n      spreadsheetId: string;\n      gid: number;\n      linkedAt: Timestamp;\n      linkedBy: string;\n    };\n    tags?: string[];\n  };\n  strings: TranslationsMap;\n}\n\nexport type DocMode = 'draft' | 'published';\n\nexport type UserRole = 'ADMIN' | 'EDITOR' | 'VIEWER';\n\nexport type HttpMethod = 'GET' | 'POST';\n\nexport interface DataSource {\n  id: string;\n  description?: string;\n  type: 'http' | 'gsheet';\n  url: string;\n  /**\n   * Currently only used by gsheet. `array` returns the sheet as an array of\n   * arrays, `map` returns the sheet as an array of objects.\n   */\n  dataFormat?: 'array' | 'map';\n  /**\n   * Options for HTTP requests.\n   */\n  httpOptions?: {\n    method: HttpMethod;\n    headers?: Record<string, string>;\n    body?: string;\n  };\n  createdAt: Timestamp;\n  createdBy: string;\n  syncedAt?: Timestamp;\n  syncedBy?: string;\n  publishedAt?: Timestamp;\n  publishedBy?: string;\n}\n\nexport interface DataSourceData<T = any> {\n  dataSource: DataSource;\n  data: T;\n}\n\nexport type DataSourceMode = 'draft' | 'published';\n\nexport interface GetDocOptions {\n  /** Mode, either \"draft\" or \"published\". */\n  mode: DocMode;\n}\n\nexport interface SetDocOptions {\n  /** Mode, either \"draft\" or \"published\". */\n  mode: DocMode;\n}\n\nexport interface SaveDraftOptions {\n  /**\n   * Locales to enable.\n   */\n  locales?: string[];\n\n  /**\n   * Email of user modifying the doc. If blank, defaults to `root-cms-client`.\n   */\n  modifiedBy?: string;\n}\n\nexport interface ListDocsOptions {\n  mode: DocMode;\n  offset?: number;\n  limit?: number;\n  orderBy?: string;\n  orderByDirection?: 'asc' | 'desc';\n  query?: (query: Query) => Query;\n  /**\n   * Whether to fetch the \"raw\" version of the doc (for use in conjunction with\n   * `setRawDoc()`).\n   */\n  raw?: boolean;\n}\n\nexport interface GetCountOptions {\n  mode: DocMode;\n  query?: (query: Query) => Query;\n}\n\nexport interface Translation {\n  [locale: string]: string;\n  source: string;\n}\n\nexport interface TranslationsMap {\n  [hash: string]: Translation;\n}\n\nexport interface LocaleTranslations {\n  [source: string]: string;\n}\n\nexport interface LoadTranslationsOptions {\n  tags?: string[];\n}\n\nexport interface Release {\n  id: string;\n  description?: string;\n  docIds?: string[];\n  createdAt?: Timestamp;\n  createdBy?: string;\n  scheduledAt?: Timestamp;\n  scheduledBy?: string;\n  publishedAt?: Timestamp;\n  publishedBy?: string;\n}\n\nexport interface Action<T = any> {\n  /**\n   * The name of the action.\n   */\n  action: string;\n  /**\n   * The user's email that performed the action (or \"system\").\n   */\n  by?: string;\n  /**\n   * Timestamp when the action occurred.\n   */\n  timestamp: Timestamp;\n  /**\n   * Metadata for the action.\n   */\n  metadata?: T;\n}\n\nexport interface ListActionsOptions {\n  /**\n   * Filter by a specific action. Defaults to all actions.\n   */\n  action?: string;\n  /**\n   * Filter by a specific user. Defaults to all users.\n   */\n  by?: string;\n  /**\n   * Max number of actions to return. Defaults to 100.\n   */\n  limit?: number;\n}\n\nexport class RootCMSClient {\n  readonly rootConfig: RootConfig;\n  readonly cmsPlugin: CMSPlugin;\n  readonly projectId: string;\n  readonly app: App;\n  readonly db: Firestore;\n\n  constructor(rootConfig: RootConfig) {\n    this.rootConfig = rootConfig;\n    this.cmsPlugin = getCmsPlugin(this.rootConfig);\n\n    const cmsPluginOptions = this.cmsPlugin.getConfig();\n    this.projectId = cmsPluginOptions.id || 'default';\n    this.app = this.cmsPlugin.getFirebaseApp();\n    this.db = this.cmsPlugin.getFirestore();\n  }\n\n  /**\n   * Retrieves doc data from Root.js CMS.\n   */\n  async getDoc<Fields = any>(\n    collectionId: string,\n    slug: string,\n    options: GetDocOptions\n  ): Promise<Doc<Fields> | null> {\n    const rawData = await this.getRawDoc(collectionId, slug, options);\n    if (rawData) {\n      return unmarshalData(rawData) as Doc<Fields>;\n    }\n    return null;\n  }\n\n  /**\n   * Retrieves raw doc data as stored in the database. Only use this if you know\n   * what you are doing.\n   */\n  async getRawDoc(\n    collectionId: string,\n    slug: string,\n    options: GetDocOptions\n  ): Promise<any | null> {\n    const mode = options.mode;\n    const docRef = this.dbDocRef(collectionId, slug, {mode});\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data();\n    }\n    return null;\n  }\n\n  dbCollectionDocsPath(\n    collectionId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    let modeCollection = '';\n    if (options.mode === 'draft') {\n      modeCollection = 'Drafts';\n    } else if (options.mode === 'published') {\n      modeCollection = 'Published';\n    } else {\n      throw new Error(`unknown mode: ${options.mode}`);\n    }\n    return `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n  }\n\n  dbDocPath(\n    collectionId: string,\n    slug: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const collectionDocsPath = this.dbCollectionDocsPath(collectionId, options);\n    // Slugs with slashes are encoded as `--` in the DB.\n    const normalizedSlug = slug.replaceAll('/', '--');\n    return `${collectionDocsPath}/${normalizedSlug}`;\n  }\n\n  dbDocRef(\n    collectionId: string,\n    slug: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const docPath = this.dbDocPath(collectionId, slug, options);\n    return this.db.doc(docPath);\n  }\n\n  /**\n   * Saves draft data to a doc.\n   *\n   * Note: this saves data to the \"fields\" attr of the draft doc. If you need to\n   * modify the sys-level attributes of the doc, use `setRawDoc()`.\n   */\n  async saveDraftData(\n    docId: string,\n    fieldsData: any,\n    options?: SaveDraftOptions\n  ) {\n    const {collection, slug} = parseDocId(docId);\n    const draftDoc =\n      (await this.getRawDoc(collection, slug, {mode: 'draft'})) || {};\n    const draftSys = draftDoc.sys || {};\n    const modifiedBy = options?.modifiedBy || 'root-cms-client';\n    const fields = marshalData(fieldsData || {});\n    const data = {\n      id: docId,\n      collection,\n      slug,\n      sys: {\n        ...draftSys,\n        createdAt: draftSys.createdAt ?? Timestamp.now(),\n        createdBy: draftSys.createdBy ?? modifiedBy,\n        modifiedAt: Timestamp.now(),\n        modifiedBy,\n        locales: options?.locales ?? draftSys.locales ?? ['en'],\n      },\n      fields,\n    };\n    await this.setRawDoc(collection, slug, data, {mode: 'draft'});\n  }\n\n  /**\n   * Prefer `saveDraftData('Pages/foo', data)`. Only use this if you know what\n   * you're doing.\n   */\n  async setRawDoc(\n    collectionId: string,\n    slug: string,\n    data: any,\n    options: SetDocOptions\n  ) {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;\n    const docRef = this.db.doc(dbPath);\n    await docRef.set(data);\n  }\n\n  /**\n   * Lists docs from a Root.js CMS collection.\n   */\n  async listDocs<T>(\n    collectionId: string,\n    options: ListDocsOptions\n  ): Promise<{docs: T[]}> {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n    let query: Query = this.db.collection(dbPath);\n    if (options.limit) {\n      query = query.limit(options.limit);\n    }\n    if (options.offset) {\n      query = query.offset(options.offset);\n    }\n    if (options.orderBy) {\n      query = query.orderBy(options.orderBy, options.orderByDirection);\n    }\n    if (options.query) {\n      query = options.query(query);\n    }\n    const results = await query.get();\n    const docs: T[] = [];\n    results.forEach((result) => {\n      if (options.raw) {\n        // For callers that wish to modify the raw doc via `setRawDoc()`,\n        // return the unmodified doc as returned from firestore.\n        const rawDoc = result.data() as T;\n        docs.push(rawDoc);\n      } else {\n        const doc = unmarshalData(result.data()) as T;\n        docs.push(doc);\n      }\n    });\n    return {docs};\n  }\n\n  /**\n   * Returns the number of docs in a Root.js CMS collection.\n   */\n  async getDocsCount(collectionId: string, options: GetCountOptions) {\n    const mode = options.mode;\n    const modeCollection = mode === 'draft' ? 'Drafts' : 'Published';\n    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;\n    let query: Query = this.db.collection(dbPath);\n    if (options.query) {\n      query = options.query(query);\n    }\n    const results = await query.count().get();\n    const count = results.data().count;\n    return count;\n  }\n\n  /**\n   * Batch publishes a set of docs by id.\n   */\n  async publishDocs(\n    docIds: string[],\n    options?: {publishedBy: string; batch?: WriteBatch}\n  ) {\n    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;\n    const publishedBy = options?.publishedBy || 'root-cms-client';\n\n    // Fetch the current draft data for each doc.\n    const docRefs = docIds.map((docId) => {\n      const [collection, slug] = docId.split('/');\n      if (!collection || !slug) {\n        throw new Error(`invalid doc id: ${docId}`);\n      }\n      const docRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      return docRef;\n    });\n    const docSnapshots = await this.db.getAll(...docRefs);\n    const docs = docSnapshots\n      // Retrieve snapshot data for each doc.\n      .map((snapshot) => snapshot.data() as Doc)\n      // Remove docs that don't exist.\n      .filter((d) => !!d);\n\n    if (docs.length === 0) {\n      console.log('no docs to publish');\n      return [];\n    }\n\n    // Verify there are no publishing locks on any docs.\n    for (const doc of docs) {\n      if (this.testPublishingLocked(doc)) {\n        throw new Error(`publishing is locked for doc: ${doc.id}`);\n      }\n    }\n\n    // // Each transaction or batch can write a max of 500 ops.\n    // // https://firebase.google.com/docs/firestore/manage-data/transactions\n    let batchCount = 0;\n    const batch = options?.batch || this.db.batch();\n    const publishedDocs: any[] = [];\n    for (const doc of docs) {\n      const {id, collection, slug, sys, fields} = doc;\n      const draftRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      const scheduledRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n      );\n      const publishedRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Published/${slug}`\n      );\n\n      // Only update `firstPublished` if it doesn't already exist.\n      const firstPublishedAt =\n        sys.firstPublishedAt ?? FieldValue.serverTimestamp();\n      const firstPublishedBy = sys.firstPublishedBy ?? publishedBy;\n\n      // Save published doc.\n      batch.set(publishedRef, {\n        id,\n        collection,\n        slug,\n        fields: fields || {},\n        sys: {\n          ...sys,\n          firstPublishedAt: firstPublishedAt,\n          firstPublishedBy: firstPublishedBy,\n          publishedAt: FieldValue.serverTimestamp(),\n          publishedBy: publishedBy,\n        },\n      });\n      batchCount += 1;\n\n      // Remove scheduled doc, if any.\n      batch.delete(scheduledRef);\n      batchCount += 1;\n\n      // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n      // and update the `publishedAt` and `publishedBy` fields.\n      batch.update(draftRef, {\n        'sys.scheduledAt': FieldValue.delete(),\n        'sys.scheduledBy': FieldValue.delete(),\n        'sys.firstPublishedAt': firstPublishedAt,\n        'sys.firstPublishedBy': firstPublishedBy,\n        'sys.publishedAt': FieldValue.serverTimestamp(),\n        'sys.publishedBy': publishedBy,\n      });\n      batchCount += 1;\n\n      this.publishTranslationsDoc(doc.id, {batch});\n      batchCount += 2;\n\n      publishedDocs.push(doc);\n\n      if (batchCount >= 400) {\n        await batch.commit();\n        batchCount = 0;\n      }\n    }\n\n    if (batchCount > 0) {\n      await batch.commit();\n    }\n    console.log(`published ${publishedDocs.length} docs!`);\n    return publishedDocs;\n  }\n\n  /**\n   * Publishes scheduled docs.\n   */\n  async publishScheduledDocs() {\n    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;\n    const now = Math.ceil(new Date().getTime());\n\n    const snapshot = await this.db.collectionGroup('Scheduled').get();\n    const docs = snapshot.docs\n      .filter((d) => {\n        // Filter docs by project.\n        if (!d.ref.path.startsWith(projectCollectionsPath)) {\n          return false;\n        }\n        // Filter docs where scheduledAt is in the past.\n        // NOTE(stevenle): the filtering is done manually instead of using a query\n        // to avoid having to create an index in firestore.\n        const data = d.data() || {};\n        const scheduledAt: Timestamp | undefined = data.sys?.scheduledAt;\n        return (\n          scheduledAt && scheduledAt.toMillis && scheduledAt.toMillis() <= now\n        );\n      })\n      .map((d) => {\n        const dbPath = d.ref.path;\n        const segments = dbPath.split('/');\n        const slug = segments.at(-1);\n        const collection = segments.at(-3);\n        const id = `${collection}/${slug}`;\n        return {\n          data: d.data(),\n          id,\n          collection,\n          slug,\n        };\n      });\n\n    if (docs.length === 0) {\n      console.log('no docs to schedule');\n      return [];\n    }\n\n    // Each transaction or batch can write a max of 500 ops.\n    // https://firebase.google.com/docs/firestore/manage-data/transactions\n    let batchCount = 0;\n    const batch = this.db.batch();\n    const publishedDocs: any[] = [];\n    for (const doc of docs) {\n      const {id, collection, slug, data} = doc;\n      const draftRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Drafts/${slug}`\n      );\n      const scheduledRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`\n      );\n      const publishedRef = this.db.doc(\n        `${projectCollectionsPath}/${collection}/Published/${slug}`\n      );\n      const {scheduledAt, scheduledBy, ...sys} = data.sys || {};\n\n      // Only update `firstPublished` if it doesn't already exist.\n      const firstPublishedAt = sys.firstPublishedAt ?? scheduledAt;\n      const firstPublishedBy =\n        sys.firstPublishedBy ?? (scheduledBy || 'root-cms-client');\n\n      // Save published doc.\n      batch.set(publishedRef, {\n        id,\n        collection,\n        slug,\n        fields: data.fields || {},\n        sys: {\n          ...sys,\n          firstPublishedAt: firstPublishedAt,\n          firstPublishedBy: firstPublishedBy,\n          publishedAt: FieldValue.serverTimestamp(),\n          publishedBy: scheduledBy || '',\n        },\n      });\n      batchCount += 1;\n\n      // Remove published doc.\n      batch.delete(scheduledRef);\n      batchCount += 1;\n\n      // Update the draft doc to remove `scheduledAt` and `scheduledBy` fields\n      // and update the `publishedAt` and `publishedBy` fields.\n      batch.update(draftRef, {\n        'sys.scheduledAt': FieldValue.delete(),\n        'sys.scheduledBy': FieldValue.delete(),\n        'sys.firstPublishedAt': firstPublishedAt,\n        'sys.firstPublishedBy': firstPublishedBy,\n        'sys.publishedAt': FieldValue.serverTimestamp(),\n        'sys.publishedBy': scheduledBy || 'root-cms-client',\n      });\n      batchCount += 1;\n\n      this.publishTranslationsDoc(doc.id, {batch});\n      batchCount += 2;\n\n      publishedDocs.push(doc);\n\n      if (batchCount >= 400) {\n        await batch.commit();\n        batchCount = 0;\n        continue;\n      }\n    }\n\n    if (batchCount > 0) {\n      await batch.commit();\n    }\n    console.log(`published ${publishedDocs.length} docs!`);\n    return publishedDocs;\n  }\n\n  /**\n   * Publishes docs in scheduled releases.\n   */\n  async publishScheduledReleases() {\n    const releasesPath = `Projects/${this.projectId}/Releases`;\n    const now = Math.ceil(new Date().getTime());\n    const query: Query = this.db\n      .collection(releasesPath)\n      .where('scheduledAt', '<=', Timestamp.fromMillis(now));\n    const querySnapshot = await query.get();\n\n    for (const snapshot of querySnapshot.docs) {\n      const release = snapshot.data() as Release;\n      const batch = this.db.batch();\n      const publishedBy = release.scheduledBy || 'root-cms-client';\n      batch.update(snapshot.ref, {\n        publishedAt: Timestamp.now(),\n        publishedBy: publishedBy,\n        scheduledAt: FieldValue.delete(),\n        scheduledBy: FieldValue.delete(),\n      });\n      await this.publishDocs(release.docIds || [], {publishedBy, batch});\n    }\n  }\n\n  async publishTranslationsDoc(\n    translationsId: string,\n    options?: {batch?: WriteBatch; publishedBy?: string}\n  ) {\n    const docSlug = translationsId.replaceAll('/', '--');\n    const draftRef = this.db.doc(\n      `Projects/${this.projectId}/TranslationsManager/draft/Translations/${docSlug}`\n    );\n    const snapshot = await draftRef.get();\n\n    if (!snapshot.exists) {\n      // Ignore missing translations.\n      console.warn(`translations ${translationsId} does not exist`);\n      return;\n    }\n\n    // If the translations publishing is tied to another batch request (e.g. doc\n    // publishing), the batch request will be committed upstream.\n    const commitBatch = !options?.batch;\n\n    const batch = options?.batch || this.db.batch();\n    batch.update(draftRef, {\n      'sys.publishedAt': Timestamp.now(),\n      'sys.publishedBy': options?.publishedBy || 'root-cms-client',\n    });\n\n    const publishedRef = this.db.doc(\n      `Projects/${this.projectId}/TranslationsManager/published/Translations/${docSlug}`\n    );\n    const data = {...snapshot.data()};\n    if (!data.sys) {\n      data.sys = {};\n    }\n    data.sys.publishedAt = Timestamp.now();\n    data.sys.publishedBy = options?.publishedBy || 'root-cms-client';\n    batch.set(publishedRef, data);\n    if (commitBatch) {\n      await batch.commit();\n      this.logAction('translations.publish', {metadata: {translationsId}});\n    }\n  }\n\n  /**\n   * Checks if a doc is currently \"locked\" for publishing.\n   */\n  testPublishingLocked(doc: Doc) {\n    if (doc.sys?.publishingLocked) {\n      if (doc.sys.publishingLocked.until) {\n        const now = Timestamp.now().toMillis();\n        const until = doc.sys.publishingLocked.until.toMillis();\n        return now < until;\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Loads all published strings in the db.\n   *\n   * ```\n   * {\n   *   \"<hash>\": {\"source\": \"Hello\", \"es\": \"Hola\", \"fr\": \"Bonjour\"},\n   * }\n   * ```\n   *\n   * @deprecated Use `createBatchRequest()` to fetch draft/published translations.\n   */\n  async loadTranslations(\n    options?: LoadTranslationsOptions\n  ): Promise<TranslationsMap> {\n    const dbPath = `Projects/${this.projectId}/TranslationsManager/published/Translations`;\n    const translationsMap: TranslationsMap = {};\n\n    const addTranslations = (hash: string, translations: Translation) => {\n      translationsMap[hash] = Object.assign(\n        translationsMap[hash] || {},\n        translations\n      );\n    };\n\n    let query: Query = this.db.collection(dbPath);\n    if (options?.tags && options.tags.length > 0) {\n      query = query.where('sys.tags', 'array-contains-any', options.tags);\n    }\n    const snapshot = await query.get();\n    snapshot.forEach((doc) => {\n      const data = doc.data();\n      const strings = (data.strings || {}) as Record<string, Translation>;\n      Object.entries(strings).forEach(([hash, translations]) => {\n        addTranslations(hash, translations);\n      });\n    });\n\n    return translationsMap;\n  }\n\n  async saveDraftTranslations(\n    translationsId: string,\n    translations: {[source: string]: {[locale: string]: string}},\n    options?: {modifiedby?: string}\n  ) {\n    const docSlug = translationsId.replaceAll('/', '--');\n    const docPath = `Projects/${this.projectId}/TranslationsManager/draft/${docSlug}`;\n    const docRef = this.db.doc(docPath);\n\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {\n      id: translationsId.replaceAll('--', '/'),\n      sys: {},\n      strings: {},\n    };\n    data.sys.modifiedAt = Timestamp.now();\n    data.sys.modifiedBy = options?.modifiedby || 'root-cms-client';\n\n    const strings = data.strings || {};\n    Object.entries(translations).forEach(([source, row]) => {\n      const normalizedSource = this.normalizeString(source);\n      const hash = this.getTranslationKey(normalizedSource);\n      strings[hash] = {...strings[hash], ...row, source: normalizedSource};\n    });\n    data.strings = strings;\n    await docRef.set(data);\n    this.logAction('translations.save', {metadata: {translationsId}});\n  }\n\n  /**\n   * Returns the \"key\" used for a translation as stored in the db. Translations\n   * are stored under `Projects/<project id>/Translations/<sha1 hash>`.\n   */\n  getTranslationKey(source: string) {\n    const sha1 = crypto\n      .createHash('sha1')\n      .update(this.normalizeString(source))\n      .digest('hex');\n    return sha1;\n  }\n\n  /**\n   * Cleans a string that's used for translations. Performs the following:\n   * - Removes any leading/trailing whitespace\n   * - Removes spaces at the end of any line\n   */\n  normalizeString(str: string) {\n    const lines = String(str)\n      .trim()\n      .split('\\n')\n      .map((line) => line.trimEnd());\n    return lines.join('\\n');\n  }\n\n  /**\n   * Loads translations for a particular locale.\n   *\n   * Returns a map like:\n   * ```\n   * {\n   *   \"Hello\": \"Bonjour\",\n   * }\n   * ```\n   */\n  async loadTranslationsForLocale(\n    locale: string,\n    options?: LoadTranslationsOptions\n  ): Promise<LocaleTranslations> {\n    const translationsMap = await this.loadTranslations(options);\n    return translationsForLocale(translationsMap, locale);\n  }\n\n  /**\n   * Returns a data source configuration object.\n   */\n  async getDataSource(dataSourceId: string) {\n    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}`;\n    const docRef = this.db.doc(dbPath);\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data() as DataSource;\n    }\n    return null;\n  }\n\n  /**\n   * Syncs a data source to draft state.\n   */\n  async syncDataSource(dataSourceId: string, options?: {syncedBy?: string}) {\n    const dataSource = await this.getDataSource(dataSourceId);\n    if (!dataSource) {\n      throw new Error(`data source not found: ${dataSourceId}`);\n    }\n\n    const data = await this.fetchData(dataSource);\n\n    const dataSourceDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}`\n    );\n    const dataDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/draft`\n    );\n    const syncedBy = options?.syncedBy || 'root-cms-client';\n\n    const updatedDataSource: DataSource = {\n      ...dataSource,\n      syncedAt: Timestamp.now(),\n      syncedBy: syncedBy,\n    };\n\n    const batch = this.db.batch();\n    batch.set(dataDocRef, {\n      dataSource: updatedDataSource,\n      data: data,\n    });\n    batch.update(dataSourceDocRef, {\n      syncedAt: Timestamp.now(),\n      syncedBy: syncedBy,\n    });\n    await batch.commit();\n\n    console.log(`synced data source: ${dataSourceId}`);\n    console.log(`synced by: ${syncedBy}`);\n  }\n\n  async publishDataSource(\n    dataSourceId: string,\n    options?: {publishedBy?: string}\n  ) {\n    const dataSource = await this.getDataSource(dataSourceId);\n    if (!dataSource) {\n      throw new Error(`data source not found: ${dataSourceId}`);\n    }\n\n    const dataSourceDocRef = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}`\n    );\n    const dataDocRefDraft = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/draft`\n    );\n    const dataDocRefPublished = this.db.doc(\n      `Projects/${this.projectId}/DataSources/${dataSourceId}/published`\n    );\n\n    const dataRes = await this.getFromDataSource(dataSourceId, {mode: 'draft'});\n\n    const publishedBy = options?.publishedBy || 'root-cms-client';\n\n    const updatedDataSource: DataSource = {\n      ...dataSource,\n      publishedAt: Timestamp.now(),\n      publishedBy: publishedBy,\n    };\n\n    const batch = this.db.batch();\n    batch.set(dataDocRefPublished, {\n      dataSource: updatedDataSource,\n      data: dataRes?.data || null,\n    });\n    batch.update(dataDocRefDraft, {\n      dataSource: updatedDataSource,\n    });\n    batch.update(dataSourceDocRef, {\n      publishedAt: Timestamp.now(),\n      publishedBy: publishedBy,\n    });\n    await batch.commit();\n\n    console.log(`published data ${dataSourceId}`);\n    console.log(`published by: ${publishedBy}`);\n  }\n\n  private async fetchData(dataSource: DataSource) {\n    if (dataSource.type === 'http') {\n      return await this.fetchHttpData(dataSource);\n    }\n    // TODO(stevenle): impl.\n    // if (dataSource.type === 'gsheet') {\n    //   return await fetchGsheetData(dataSource);\n    // }\n    throw new Error(`unsupported data source: ${dataSource.type}`);\n  }\n\n  private async fetchHttpData(dataSource: DataSource) {\n    const url = dataSource.url || '';\n    if (!url.startsWith('https://')) {\n      throw new Error(`url not supported: ${url}`);\n    }\n\n    const res = await fetch(url, {\n      method: dataSource.httpOptions?.method || 'GET',\n      headers: dataSource.httpOptions?.headers || [],\n      body: dataSource.httpOptions?.body || undefined,\n    });\n\n    if (res.status !== 200) {\n      const err = await res.text();\n      throw new Error(`req failed: ${err}`);\n    }\n\n    const contentType = String(res.headers.get('content-type'));\n    if (contentType.includes('application/json')) {\n      return await res.json();\n    }\n    return res.text();\n  }\n\n  /**\n   * Fetches data from a data source.\n   */\n  async getFromDataSource<T = any>(\n    dataSourceId: string,\n    options?: {mode?: 'draft' | 'published'}\n  ): Promise<DataSourceData<T> | null> {\n    const mode = options?.mode || 'published';\n\n    const docRef = this.dbDataSourceDataRef(dataSourceId, {mode});\n    const doc = await docRef.get();\n    if (doc.exists) {\n      return doc.data() as DataSourceData<T>;\n    }\n    return null;\n  }\n\n  dbDataSourceDataPath(\n    dataSourceId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    if (!dataSourceId || dataSourceId.includes('/')) {\n      throw new Error(`invalid data source id: ${dataSourceId}`);\n    }\n    const mode = options.mode;\n    if (!(mode === 'draft' || mode === 'published')) {\n      throw new Error(`invalid mode: ${mode}`);\n    }\n    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/${mode}`;\n    return dbPath;\n  }\n\n  dbDataSourceDataRef(\n    dataSourceId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const dbPath = this.dbDataSourceDataPath(dataSourceId, options);\n    return this.db.doc(dbPath);\n  }\n\n  dbTranslationsPath(\n    translationsId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const mode = options.mode;\n    if (!(mode === 'draft' || mode === 'published')) {\n      throw new Error(`invalid mode: ${mode}`);\n    }\n    const slug = translationsId.replaceAll('/', '--');\n    const dbPath = `Projects/${this.projectId}/TranslationsManager/${mode}/Translations/${slug}`;\n    return dbPath;\n  }\n\n  dbTranslationsRef(\n    translationsId: string,\n    options: {mode: 'draft' | 'published'}\n  ) {\n    const dbPath = this.dbTranslationsPath(translationsId, options);\n    return this.db.doc(dbPath);\n  }\n\n  /**\n   * Gets the user's role from the project's ACL.\n   */\n  async getUserRole(email: string): Promise<UserRole | null> {\n    if (!email) {\n      return null;\n    }\n    const docRef = this.db.doc(`Projects/${this.projectId}`);\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {};\n    const acl = data.roles || {};\n\n    if (email in acl) {\n      return acl[email];\n    }\n\n    // Check wildcard domains, e.g. `*@example.com`.\n    if (!email.includes('@')) {\n      console.warn(`invalid email: ${email}`);\n      return null;\n    }\n    const domain = email.split('@').at(-1);\n    if (domain && `*@${domain}` in acl) {\n      return acl[`*@${domain}`];\n    }\n    return null;\n  }\n\n  /**\n   * Verifies user exists in the ACL list.\n   */\n  async userExistsInAcl(email: string): Promise<boolean> {\n    if (!email) {\n      return false;\n    }\n    const docRef = this.db.doc(`Projects/${this.projectId}`);\n    const snapshot = await docRef.get();\n    const data = snapshot.data() || {};\n    const acl = data.roles || {};\n    if (email in acl) {\n      return true;\n    }\n\n    // Check wildcard domains, e.g. `*@example.com`.\n    if (!email.includes('@')) {\n      console.warn(`invalid email: ${email}`);\n      return false;\n    }\n    const domain = email.split('@').at(-1);\n    if (domain && `*@${domain}` in acl) {\n      return true;\n    }\n    return false;\n  }\n\n  async logAction(action: string, options?: {by?: string; metadata?: any}) {\n    if (!action) {\n      throw new Error('missing required: \"action\"');\n    }\n    const data = {\n      action: action,\n      timestamp: Timestamp.now(),\n      by: options?.by || 'system',\n      metadata: options?.metadata || {},\n    };\n    const colRef = this.db.collection(`Projects/${this.projectId}/ActionLogs`);\n    await colRef.add(data);\n\n    const metaStr = options?.metadata ? stringifyObj(options.metadata) : '';\n    console.log(`[${data.timestamp.toMillis()}] action: ${action} ${metaStr}`);\n\n    // Call the `onAction()` callback from cmsPlugin().\n    const cmsPluginConfig = this.cmsPlugin.getConfig();\n    if (cmsPluginConfig.onAction) {\n      try {\n        cmsPluginConfig.onAction(data);\n      } catch (err) {\n        console.error(err);\n      }\n    }\n  }\n\n  createBatchRequest(options: BatchRequestOptions): BatchRequest {\n    return new BatchRequest(this, options);\n  }\n}\n\nexport interface BatchRequestOptions {\n  mode: 'draft' | 'published';\n  /**\n   * Whether to automatically fetch translations for the docs retrieved in the\n   * request.\n   */\n  translate?: boolean;\n}\n\nexport interface BatchRequestQuery {\n  queryId: string;\n  collectionId: string;\n  queryOptions?: BatchRequestQueryOptions;\n}\n\nexport interface BatchRequestQueryOptions {\n  offset?: number;\n  limit?: number;\n  orderBy?: string;\n  orderByDirection?: 'asc' | 'desc';\n  query?: (query: Query) => Query;\n}\n\nexport class BatchRequest {\n  cmsClient: RootCMSClient;\n  private options: BatchRequestOptions;\n  private db: Firestore;\n  private docIds: string[] = [];\n  private dataSourceIds: string[] = [];\n  private queries: BatchRequestQuery[] = [];\n  private translationsIds: string[] = [];\n\n  constructor(cmsClient: RootCMSClient, options: BatchRequestOptions) {\n    this.cmsClient = cmsClient;\n    this.db = cmsClient.db;\n    this.options = options;\n  }\n\n  /**\n   * Adds a doc to the batch request.\n   */\n  addDoc(docId: string) {\n    this.docIds.push(docId);\n  }\n\n  /**\n   * Adds a data source to the batch request.\n   */\n  addDataSource(dataSourceId: string) {\n    this.dataSourceIds.push(dataSourceId);\n  }\n\n  /**\n   * Adds a collection-based query to the batch request.\n   */\n  addQuery(\n    queryId: string,\n    collectionId: string,\n    queryOptions?: BatchRequestQueryOptions\n  ) {\n    this.queries.push({\n      queryId: queryId,\n      collectionId: collectionId,\n      queryOptions: queryOptions,\n    });\n  }\n\n  /**\n   * Adds a translation file to the request.\n   */\n  addTranslations(translationsId: string) {\n    this.translationsIds.push(translationsId);\n  }\n\n  /**\n   * Fetches data from the DB.\n   */\n  async fetch(): Promise<BatchResponse> {\n    const res = new BatchResponse();\n\n    const promises = [\n      this.fetchDocs(res),\n      this.fetchQueries(res),\n      this.fetchDataSources(res),\n    ];\n    // If `options.translate` is disabled and translations are requested,\n    // fetch the translations in parallel with the other docs.\n    if (!this.options.translate && this.translationsIds.length > 0) {\n      promises.push(this.fetchTranslations(res));\n    }\n\n    await Promise.all(promises);\n\n    // If `options.translate` is enabled, the fetchX() methods will\n    // automatically add each doc's translations id to the request, so\n    // translations should be fetched after all the other docs are fetched.\n    if (this.translationsIds.length > 0) {\n      await this.fetchTranslations(res);\n    }\n\n    return res;\n  }\n\n  private async fetchDocs(res: BatchResponse) {\n    if (this.docIds.length === 0) {\n      return;\n    }\n    const docRefs = this.docIds.map((docId) => {\n      const [collectionId, slug] = docId.split('/');\n      return this.cmsClient.dbDocRef(collectionId, slug, {\n        mode: this.options.mode,\n      });\n    });\n    const docs = await this.db.getAll(...docRefs);\n    this.docIds.forEach((docId, i) => {\n      const doc = docs[i];\n      if (!doc.exists) {\n        console.warn(`doc \"${docId}\" does not exist`);\n        return;\n      }\n      const docData = unmarshalData(doc.data()) as Doc;\n      res.docs[docId] = docData;\n\n      if (this.options.translate) {\n        this.addTranslations(docId);\n      }\n    });\n  }\n\n  private async fetchQueries(res: BatchResponse) {\n    if (this.queries.length === 0) {\n      return;\n    }\n    const mode = this.options.mode;\n\n    const handleQuery = async (queryItem: BatchRequestQuery) => {\n      const docsPath = this.cmsClient.dbCollectionDocsPath(\n        queryItem.collectionId,\n        {mode}\n      );\n      const queryOptions = queryItem.queryOptions || {};\n      let query: Query = this.db.collection(docsPath);\n      if (queryOptions.limit) {\n        query = query.limit(queryOptions.limit);\n      }\n      if (queryOptions.offset) {\n        query = query.offset(queryOptions.offset);\n      }\n      if (queryOptions.orderBy) {\n        query = query.orderBy(\n          queryOptions.orderBy,\n          queryOptions.orderByDirection\n        );\n      }\n      if (queryOptions.query) {\n        query = queryOptions.query(query);\n      }\n      const results = await query.get();\n      const docs: Doc[] = [];\n      results.forEach((result) => {\n        const doc = unmarshalData(result.data()) as Doc;\n        docs.push(doc);\n      });\n      res.queries[queryItem.queryId] = docs;\n    };\n\n    await Promise.all(this.queries.map((queryItem) => handleQuery(queryItem)));\n  }\n\n  private async fetchDataSources(res: BatchResponse) {\n    if (this.dataSourceIds.length === 0) {\n      return;\n    }\n    const docRefs = this.dataSourceIds.map((dataSourceId) => {\n      return this.cmsClient.dbDataSourceDataRef(dataSourceId, {\n        mode: this.options.mode,\n      });\n    });\n    const docs = await this.db.getAll(...docRefs);\n    this.dataSourceIds.forEach((dataSourceId, i) => {\n      const doc = docs[i];\n      if (!doc.exists) {\n        console.warn(`\"data source \"${dataSourceId}\" does not exist`);\n        return;\n      }\n      res.dataSources[dataSourceId] = doc.data() as DataSourceData;\n    });\n  }\n\n  private async fetchTranslations(res: BatchResponse) {\n    if (this.translationsIds.length === 0) {\n      return;\n    }\n\n    const docRefs = this.translationsIds.map((translationsId) => {\n      return this.cmsClient.dbTranslationsRef(translationsId, {\n        mode: this.options.mode,\n      });\n    });\n    const docs = await this.db.getAll(...docRefs);\n    this.translationsIds.forEach((translationsId, i) => {\n      const doc = docs[i];\n      if (!doc.exists) {\n        // console.warn(`translations \"${translationsId}\" does not exist`);\n        return;\n      }\n      res.translations[translationsId] = doc.data() as TranslationsDoc;\n    });\n  }\n}\n\nexport class BatchResponse {\n  docs: Record<string, Doc> = {};\n  queries: Record<string, Doc[]> = {};\n  dataSources: Record<string, DataSourceData> = {};\n  translations: Record<string, TranslationsDoc> = {};\n\n  /**\n   * Returns a map of translations for a given locale or locale fallbacks.\n   *\n   * The input is either a single locale (e.g. \"de\") or an array of locales\n   * representing the fallback tree, e.g. [\"en-CA\", \"en-GB\", \"en\"].\n   *\n   * The returned value is a flat map of source string to translated string,\n   * e.g.:\n   * {\"<source>\": \"<translation>\"}\n   */\n  getTranslations(locale: string | string[]): LocaleTranslations {\n    const translationsMap = this.getTranslationsMap();\n    const translations = translationsForLocale(translationsMap, locale);\n    return translations;\n  }\n\n  /**\n   * Merges the strings from all translations files retrieved in the request.\n   * The returned value is a map of string to translations, e.g.:\n   *\n   * {\"<hash>\": {\"source\": \"<source>\", \"<locale>\": \"<translation>\"}}\n   */\n  private getTranslationsMap(): TranslationsMap {\n    // Load translations in the following order:\n    // - generic translations (e.g. \"global\")\n    // - docs returned from queries (e.g. \"list all blog posts\")\n    // - specific docs (e.g. \"Pages/index\")\n    const translationsDocs = Object.values(this.translations).reverse();\n\n    // Consolidate the strings from all of the translations files.\n    // {\"<hash>\": {\"source\": \"<source>\", \"<locale>\": \"<translation>\"}}\n    const translationsMap: TranslationsMap = {};\n    for (const translationsDoc of translationsDocs) {\n      const strings = translationsDoc.strings || {};\n      for (const hash in strings) {\n        const translations = strings[hash];\n        translationsMap[hash] ??= {source: translations.source};\n        for (const locale in translations) {\n          if (locale !== 'source' && translations[locale]) {\n            translationsMap[hash][locale] = translations[locale];\n          }\n        }\n      }\n    }\n\n    return translationsMap;\n  }\n}\n\n/**\n * Returns true if the `data` is a rich text data object.\n */\nexport function isRichTextData(data: any) {\n  // The RichTextEditor uses editorjs under the hood, the data format is\n  // something like:\n  //  {\n  //   \"time\": 1721761211720,\n  //   \"version\": \"2.28.2\",\n  //   \"blocks\": [...]\n  // }\n  return Boolean(\n    isObject(data) && Array.isArray(data.blocks) && data.time && data.version\n  );\n}\n\n/**\n * Walks the data tree and converts any array of objects into \"array objects\"\n * for storage in firestore.\n */\nexport function marshalData(data: any): any {\n  // Avoid changing the format of rich text data.\n  if (isRichTextData(data)) {\n    return data;\n  }\n\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      result[key] = marshalData(val);\n    } else if (Array.isArray(val)) {\n      if (val.length > 0 && val.some((item) => isObject(item))) {\n        const items = val.map((item) => {\n          if (isObject(item)) {\n            return marshalData(item);\n          }\n          return item;\n        });\n        result[key] = toArrayObject(items);\n      } else {\n        result[key] = val;\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\n/**\n * Walks the data tree and converts any Timestamp objects to millis and any\n * _array maps to normal arrays.\n *\n * E.g.:\n *\n * normalizeData({\n *   sys: {modifiedAt: Timestamp(123)},\n *   fields: {\n *     _array: ['asdf'],\n *     asdf: {title: 'hello'}\n *   }\n * })\n * // => {sys: {modifiedAt: 123}, fields: {foo: [{title: 'hello'}]}}\n */\nexport function unmarshalData(data: any): any {\n  const result: any = {};\n  for (const key in data) {\n    const val = data[key];\n    if (isObject(val)) {\n      if (val.toMillis) {\n        result[key] = val.toMillis();\n      } else if (Object.hasOwn(val, '_array') && Array.isArray(val._array)) {\n        const arr = val._array.map((arrayKey: string) => {\n          return {\n            ...unmarshalData(val[arrayKey] || {}),\n            _arrayKey: arrayKey,\n          };\n        });\n        result[key] = arr;\n      } else {\n        result[key] = unmarshalData(val);\n      }\n    } else {\n      result[key] = val;\n    }\n  }\n  return result;\n}\n\n/** @deprecated Use `unmarshalData()` instead. */\nexport function normalizeData(data: any): any {\n  return unmarshalData(data);\n}\n\nexport interface ArrayObject {\n  [key: string]: any;\n  _array: string[];\n}\n\n/**\n * Serializes an array into an `ArrayObject`, e.g.:\n *\n * ```\n * marshalArray([1, 2, 3])\n * // => {a: 1, b: 2, c: 3, _array: ['a', 'b', 'c']}\n * ```\n *\n * This database storage method makes it easier to update a single field in a\n * deeply nested array object.\n */\nexport function toArrayObject(arr: any[]): ArrayObject {\n  if (!Array.isArray(arr)) {\n    return arr;\n  }\n  const arrObject: ArrayObject = {_array: []};\n  for (const item of arr) {\n    const key = randString(6);\n    arrObject[key] = item;\n    arrObject._array.push(key);\n  }\n  return arrObject;\n}\n\nexport const marshalArray = toArrayObject;\n\n/**\n * Converts an `ArrayObject` to a normal array.\n */\nexport function unmarshalArray(arrObject: ArrayObject): any[] {\n  if (!Array.isArray(arrObject?._array)) {\n    return [];\n  }\n  const arr = arrObject._array.map((k: string) => arrObject[k]);\n  return arr;\n}\n\nfunction isObject(data: any): boolean {\n  return typeof data === 'object' && !Array.isArray(data) && data !== null;\n}\n\nfunction randString(len: number): string {\n  const result = [];\n  const chars =\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n  for (let i = 0; i < len; i++) {\n    const rand = Math.floor(Math.random() * chars.length);\n    result.push(chars.charAt(rand));\n  }\n  return result.join('');\n}\n\n/**\n * Converts a translations map from `loadTranslations()` to a map of source to\n * translated string for a particular locale.\n *\n * Returns a map like:\n * ```\n * {\n *   \"Hello\": \"Bonjour\",\n * }\n * ```\n */\nexport function translationsForLocale(\n  translationsMap: TranslationsMap,\n  locale: string | string[]\n) {\n  const localeTranslations: LocaleTranslations = {};\n\n  const fallbackLocales = Array.isArray(locale) ? locale : [locale];\n  if (!fallbackLocales.includes('en')) {\n    fallbackLocales.push('en');\n  }\n\n  Object.values(translationsMap).forEach((string) => {\n    const source = string.source;\n    let translation = source;\n    for (const fallbackLocale of fallbackLocales) {\n      if (string[fallbackLocale]) {\n        translation = string[fallbackLocale];\n        break;\n      }\n    }\n    localeTranslations[source] = translation;\n  });\n  return localeTranslations;\n}\n\n/** A pretty printer for JavaScript objects. */\nfunction stringifyObj(obj: any) {\n  function format(obj: any): string {\n    if (obj === null) {\n      return 'null';\n    }\n    if (typeof obj === 'undefined') {\n      return 'undefined';\n    }\n    if (typeof obj === 'string') {\n      return `\"${obj.replaceAll('\"', '\\\\\"')}\"`;\n    }\n    if (typeof obj !== 'object') {\n      return String(obj);\n    }\n    if (Array.isArray(obj)) {\n      return `[${obj.map(format).join(', ')}]`;\n    }\n    const entries: string[] = Object.entries(obj).map(([key, value]) => {\n      return `${key}: ${format(value)}`;\n    });\n    return `{${entries.join(', ')}}`;\n  }\n  return format(obj);\n}\n\n/**\n * Parses a docId (e.g. `Pages/foo`) and returns the `collection` and `slug`.\n */\nexport function parseDocId(docId: string) {\n  const sepIndex = docId.indexOf('/');\n  if (sepIndex <= 0) {\n    throw new Error(`invalid doc id: ${docId}`);\n  }\n  const collection = docId.slice(0, sepIndex);\n  const slug = docId.slice(sepIndex + 1).replaceAll('/', '--');\n  if (!collection || !slug) {\n    throw new Error(`invalid doc id: ${docId}`);\n  }\n  return {collection, slug};\n}\n\nexport {getCmsPlugin};\n", "/**\n * Document verion history.\n *\n * Verions save the state of a document at different moments in time, allowing\n * users to revert back to a version if/when needed.\n *\n * The saveVersions() function is meant to be run within a cron job (e.g using\n * firebase functions). Every minute, the runner checks for all documents that\n * have been edited since the last run. To avoid saving \"partial\" versions\n * (when the user might be in the middle of editing a document), versions only\n * run on documents that haven't been edited within the last 5 mins to ensure\n * that version is \"stable\".\n *\n * In the database, versions are stored as:\n * /Projects/<projectId>/Collections/<collectionId>/Drafts/<docId>/Versions/<timestamp>\n *\n * Where <timestamp> is the unix timestamp (millis) that the document was last\n * edited.\n */\n\nimport path from 'node:path';\nimport {RootConfig} from '@blinkk/root';\nimport {Firestore, Query, Timestamp} from 'firebase-admin/firestore';\nimport glob from 'tiny-glob';\nimport {getCmsPlugin} from './client.js';\n\n// To avoid saving \"partial\" versions (when the user might be in the middle of\n// editing a document), versions only run on documents that haven't been edited\n// within the last 5 mins to ensure that version is \"stable\".\nconst DOCUMENT_SAVE_OFFSET = 5 * 60 * 1000;\n\ninterface PartialCMSDoc {\n  [key: string]: any;\n  id: string;\n  collection: string;\n  slug: string;\n  sys: {\n    modifiedAt: Timestamp;\n    modifiedBy: string;\n  };\n}\n\nexport class VersionsService {\n  private readonly rootConfig: RootConfig;\n  private readonly projectId: string;\n  private readonly db: Firestore;\n\n  constructor(rootConfig: RootConfig) {\n    this.rootConfig = rootConfig;\n    const cmsPlugin = getCmsPlugin(rootConfig);\n    const cmsPluginOptions = cmsPlugin.getConfig();\n    const projectId = cmsPluginOptions.id || 'default';\n    this.projectId = projectId;\n    this.db = cmsPlugin.getFirestore();\n  }\n\n  /**\n   * Saves a version of all documents that have been edited since the last run.\n   */\n  async saveVersions() {\n    // Offset the \"last run\" time by 5 mins. Versions ignore docs that were\n    // edited within the last 5 mins to avoid potential \"partial\" versions when\n    // user is in the middle of editing a document.\n    const lastRun = await this.getLastRun();\n    const lastRunWithOffset =\n      lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;\n    const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);\n    const now = Timestamp.now().toMillis();\n    const versions = changedDocs.filter((doc) => {\n      const modifiedAt = doc.sys.modifiedAt.toMillis();\n      return modifiedAt <= now - DOCUMENT_SAVE_OFFSET;\n    });\n    if (versions.length > 0) {\n      this.saveVersionsToFirestore(versions);\n    }\n    this.saveLastRun(now);\n  }\n\n  private async saveVersionsToFirestore(versions: PartialCMSDoc[]) {\n    const batch = this.db.batch();\n    versions.forEach((version) => {\n      if (!version.collection || !version.slug || !version.sys?.modifiedAt) {\n        return;\n      }\n      const modifiedAtMillis = version.sys.modifiedAt.toMillis();\n      const versionPath = `Projects/${this.projectId}/Collections/${version.collection}/Drafts/${version.slug}/Versions/${modifiedAtMillis}`;\n      console.log(versionPath);\n      const versionRef = this.db.doc(versionPath);\n      batch.set(versionRef, version);\n    });\n    await batch.commit();\n    console.log(`versions: saved ${versions.length} versions`);\n  }\n\n  /**\n   * Returns the last time (in millis) saveVersions() was run, or 0 if has\n   * never been run.\n   */\n  private async getLastRun(): Promise<number> {\n    const projectDocRef = this.db.collection('Projects').doc(this.projectId);\n    const projectDoc = await projectDocRef.get();\n    if (projectDoc.exists) {\n      const data = projectDoc.data() || {};\n      const ts = data.versionsLastRun as Timestamp;\n      if (ts) {\n        return ts.toMillis();\n      }\n    }\n    return 0;\n  }\n\n  /**\n   * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.\n   */\n  private async saveLastRun(millis: number) {\n    const ts = Timestamp.fromMillis(millis);\n    const projectDocRef = this.db.collection('Projects').doc(this.projectId);\n    await projectDocRef.set({versionsLastRun: ts}, {merge: true});\n  }\n\n  /**\n   * Returns a list of all docs that were edited after a certain time.\n   */\n  private async getDocsModifiedAfter(millis: number): Promise<PartialCMSDoc[]> {\n    const ts = Timestamp.fromMillis(millis);\n    const results: PartialCMSDoc[] = [];\n    const collectionIds = await this.listCollections();\n    // NOTE: Individual collections are queried instead of using a\n    // collectionGroup query because the latter requires a firestore index to be\n    // set up.\n    for (const collectionId of collectionIds) {\n      const collectionPath = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;\n      const query: Query = this.db\n        .collection(collectionPath)\n        .where('sys.modifiedAt', '>=', ts);\n      const querySnapshot = await query.get();\n      querySnapshot.forEach((doc) => {\n        results.push(doc.data() as PartialCMSDoc);\n      });\n    }\n    return results;\n  }\n\n  /**\n   * Returns a list of collection ids for the Root project.\n   */\n  private async listCollections(): Promise<string[]> {\n    const collectionIds: string[] = [];\n    const collectionFileNames = await glob('*.schema.ts', {\n      cwd: path.join(this.rootConfig.rootDir, 'collections'),\n    });\n    collectionFileNames.forEach((filename) => {\n      collectionIds.push(filename.slice(0, -10));\n    });\n    return collectionIds;\n  }\n}\n", "import {RootConfig} from '@blinkk/root';\nimport {RootCMSClient} from './client.js';\nimport {VersionsService} from './versions.js';\n\nexport async function runCronJobs(rootConfig: RootConfig) {\n  await Promise.all([\n    runCronJob('publishScheduledDocs', runPublishScheduledDocs, rootConfig),\n    runCronJob('saveVersions', runSaveVersions, rootConfig),\n  ]);\n}\n\nasync function runCronJob(\n  name: string,\n  fn: (...args: any[]) => any,\n  ...args: any[]\n) {\n  try {\n    await fn(...args);\n  } catch (err) {\n    console.log(`cron failed: ${name}`);\n    console.error(String(err.stack || err));\n    throw err;\n  }\n}\n\nasync function runPublishScheduledDocs(rootConfig: RootConfig) {\n  const cmsClient = new RootCMSClient(rootConfig);\n  await cmsClient.publishScheduledDocs();\n  await cmsClient.publishScheduledReleases();\n}\n\nasync function runSaveVersions(rootConfig: RootConfig) {\n  const service = new VersionsService(rootConfig);\n  await service.saveVersions();\n}\n", "import {parse as csvParse} from 'csv-parse/sync';\nimport {stringify as csvStringify} from 'csv-stringify/sync';\n\nexport function arrayToCsv(req: {\n  headers: string[];\n  rows: Array<Record<string, any>>;\n}): string {\n  const headers = req.headers || [];\n  const rows = req.rows || [];\n  return csvStringify(rows, {\n    header: true,\n    columns: headers,\n  });\n}\n\nexport function csvToArray(csvString: string) {\n  const rows = csvParse(csvString, {\n    columns: true,\n    skip_empty_lines: true,\n  });\n  return rows;\n}\n", "import {RootConfig} from '@blinkk/root';\nimport {Timestamp} from 'firebase-admin/firestore';\nimport {RootCMSClient, Translation, TranslationsDoc} from './client.js';\n\n/**\n * Runs compatibility checks to ensure the current version of root supports\n * any backwards-incompatible db changes.\n *\n * Compatibility versions are stored in the db in Projects/<projectId> under\n * the \"compatibility\" key. If the compatibility version is less than the\n * latest version, a backwards-friendly \"migration\" is done to ensure\n * compatibility on both the old and new versions.\n */\nexport async function runCompatibilityChecks(rootConfig: RootConfig) {\n  const cmsClient = new RootCMSClient(rootConfig);\n  const projectId = cmsClient.projectId;\n  const db = cmsClient.db;\n  const projectConfigDocRef = db.doc(`Projects/${projectId}`);\n  const projectConfigDoc = await projectConfigDocRef.get();\n  const projectConfig = projectConfigDoc.data() || {};\n\n  const compatibilityVersions = projectConfig.compatibility || {};\n  let versionsChanged = false;\n\n  const translationsVersion = compatibilityVersions.translations || 0;\n  if (translationsVersion < 2) {\n    await migrateTranslationsToV2(rootConfig, cmsClient);\n    compatibilityVersions.translations = 2;\n    versionsChanged = true;\n  }\n\n  if (versionsChanged) {\n    await projectConfigDocRef.update({compatibility: compatibilityVersions});\n    console.log('[root cms] updated db compatibility');\n  }\n}\n\n/**\n * Migrates translations from the \"v1\" format to \"v2\".\n */\nasync function migrateTranslationsToV2(\n  rootConfig: RootConfig,\n  cmsClient: RootCMSClient\n) {\n  if (rootConfig.experiments?.rootCmsDisableTranslationsToV2Check) {\n    return;\n  }\n\n  const projectId = cmsClient.projectId;\n  const db = cmsClient.db;\n  const dbPath = `Projects/${projectId}/Translations`;\n  const query = db.collection(dbPath);\n  const querySnapshot = await query.get();\n  if (querySnapshot.size === 0) {\n    return;\n  }\n\n  console.log('[root cms] updating translations v2 compatibility');\n\n  const translationsDocs: Record<string, TranslationsDoc> = {};\n  querySnapshot.forEach((doc) => {\n    const hash = doc.id;\n    const translation = doc.data() as Translation;\n    const tags = (translation.tags || []) as string[];\n    delete translation.tags;\n    for (const tag of tags) {\n      if (tag.includes('/')) {\n        const translationsId = tag.replaceAll('/', '--');\n        translationsDocs[translationsId] ??= {\n          id: translationsId,\n          sys: {\n            modifiedAt: Timestamp.now(),\n            modifiedBy: 'root-cms-client',\n            publishedAt: Timestamp.now(),\n            publishedBy: 'root-cms-client',\n            tags: tags,\n          },\n          strings: {},\n        };\n        translationsDocs[translationsId].strings[hash] = translation;\n      }\n    }\n  });\n\n  if (Object.keys(translationsDocs).length === 0) {\n    console.log('[root cms] no translations to save');\n    return;\n  }\n\n  // Move the doc's \"l10nSheet\" to the translations doc's \"linkedSheet\".\n\n  for (const docId in translationsDocs) {\n    const [collection, slug] = docId.split('/');\n    if (collection && slug) {\n      const doc: any = await cmsClient.getDoc(collection, slug, {\n        mode: 'draft',\n      });\n      const linkedSheet = doc?.sys?.l10nSheet;\n      if (linkedSheet) {\n        translationsDocs[docId].sys.linkedSheet = linkedSheet;\n      }\n    }\n  }\n\n  const batch = db.batch();\n  Object.entries(translationsDocs).forEach(([translationsId, data]) => {\n    const draftRef = db.doc(\n      `Projects/${projectId}/TranslationsManager/draft/Translations/${translationsId}`\n    );\n    const publishedRef = db.doc(\n      `Projects/${projectId}/TranslationsManager/published/Translations/${translationsId}`\n    );\n    batch.set(draftRef, data, {merge: true});\n    batch.set(publishedRef, data, {merge: true});\n    const len = Object.keys(data.strings).length;\n    console.log(`[root cms] saving ${len} string(s) to ${translationsId}...`);\n  });\n  await batch.commit();\n\n  console.log('[root cms] done migrating translations to v2');\n}\n"],
  "mappings": ";;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAQ,YAAY,UAAS;AAC7B,OAAOA,WAAU;AACjB,SAAQ,qBAAoB;AAC5B,SAAQ,gBAAgB,yBAAwB;AAChD,YAAY,SAAS;AAOrB,eAAsB,gBAAgB;AACpC,QAAM,UAAU,QAAQ,IAAI;AAC5B,QAAM,aAAa,MAAM,eAAe,SAAS,EAAC,SAAS,WAAU,CAAC;AACtE,QAAM,aAAaA,MAAK,QAAQ,WAAW,cAAc;AACzD,QAAM,UAAW,MAAM;AAAA,IACrB;AAAA,IACA;AAAA,EACF;AACA,QAAM,UAAU,QAAQ,kBAAkB;AAC1C,QAAM,aAAaA,MAAK,QAAQ,SAAS,eAAe;AACxD,QAAM,kBAAkB,YAAY,OAAO;AAC3C,UAAQ,IAAI,sBAAsB;AACpC;AA2DA,eAAsB,kBACpB,YACA,SACA;AACA,QAAM,UAAU,CAAC,QAAQ;AACzB,aAAW,UAAU,SAAS;AAC5B,UAAM,SAAS,QAAQ,MAAM;AAC7B,YAAQ,KAAK,aAAa,QAAQ,MAAM,CAAC;AAAA,EAC3C;AACA,QAAM,SAAS,QACZ,KAAK,MAAM,EACX,WAAW,SAAS,MAAM,EAC1B,WAAW,QAAQ,KAAK,EACxB,QAAQ,eAAe,IAAI;AAC9B,QAAM,GAAG,UAAU,YAAY,QAAQ,OAAO;AAChD;AAEA,SAAS,cAAc,OAAuC;AAC5D,QAAM,OAAW,WAAO;AAAA,IACtB,MAAM;AAAA,IACN,UAAU,KAAK;AAAA,IACX,qBAAiB;AAAA,EACvB;AACA,QAAM,QAAQ,CAAC;AACf,MAAI,MAAM,OAAO;AACf,QAAI,MAAM,MAAM;AACd,YAAM,KAAK,GAAG,MAAM,KAAK,KAAK,MAAM,IAAI,EAAE;AAAA,IAC5C,OAAO;AACL,YAAM,KAAK,MAAM,KAAK;AAAA,IACxB;AAAA,EACF;AACA,MAAI,MAAM,YAAY;AACpB,UAAM,KAAK,aAAa;AAAA,EAC1B;AACA,MAAI,MAAM,SAAS,GAAG;AACpB,SAAK,eAAe,MAAM,KAAK,IAAI;AAAA,EACrC;AACA,SAAO;AACT;AAEA,SAAS,UAAU,OAAwB;AACzC,MAAI,MAAM,SAAS,SAAS;AAC1B,WAAW,SAAK,MAAM,UAAU,MAAM,EAAE,CAAC;AAAA,EAC3C;AACA,MAAI,MAAM,SAAS,WAAW;AAC5B,WAAW,SAAK;AAAA,EAClB;AACA,MAAI,MAAM,SAAS,QAAQ;AACzB,WAAW,SAAK;AAAA,EAClB;AACA,MAAI,MAAM,SAAS,YAAY;AAC7B,WAAW,SAAK;AAAA,EAClB;AACA,MAAI,MAAM,SAAS,SAAS;AAC1B,UAAM,YAAgB,WAAO,mBAAmB,cAAc;AAC9D,WAAO;AAAA,EACT;AACA,MAAI,MAAM,SAAS,QAAQ;AACzB,WAAW,WAAO,WAAW,CAAK,WAAO,SAAS,OAAW,SAAK,MAAM,CAAC,CAAC;AAAA,EAC5E;AACA,MAAI,MAAM,SAAS,eAAe;AAChC,WAAW,SAAK,MAAU,SAAK,MAAM;AAAA,EACvC;AACA,MAAI,MAAM,SAAS,SAAS;AAC1B,UAAM,YAAgB,WAAO,mBAAmB,cAAc;AAC9D,WAAO;AAAA,EACT;AACA,MAAI,MAAM,SAAS,aAAa;AAC9B,UAAM,gBAAoB,WAAO,mBAAmB,kBAAkB;AACtE,WAAO;AAAA,EACT;AACA,MAAI,MAAM,SAAS,YAAY;AAC7B,UAAM,eAAmB,WAAO,mBAAmB,iBAAiB;AACpE,WAAO;AAAA,EACT;AACA,MAAI,MAAM,SAAS,UAAU;AAC3B,WAAW,SAAK;AAAA,EAClB;AACA,MAAI,MAAM,SAAS,UAAU;AAC3B,WAAW,SAAK;AAAA,EAClB;AACA,MAAI,MAAM,SAAS,UAAU;AAC3B,UAAM,iBAAiB,MAAM,UAAU,CAAC,GAAG,IAAI,CAAC,MAAM,cAAc,CAAC,CAAC;AACtE,WAAW,WAAO,WAAW,aAAa;AAAA,EAC5C;AACA,SAAW,SAAK;AAClB;AAEA,SAAS,aAAa,QAAgB,QAAwB;AAC5D,QAAM,QAAQ,oBAAoB,MAAM;AACxC,QAAM,KAAK,aAAaA,MAAK,MAAM,MAAM,EAAE,KAAK,MAAM,GAAG,EAAE,CAAC,CAAC;AAC7D,QAAM,kBAAkB,GAAG,EAAE;AAC7B,QAAM,SAAa,WAAO;AAAA,IACxB;AAAA,IACI,qBAAiB;AAAA,EACvB;AACA,SAAO,eAAe;AACtB,aAAW,SAAS,OAAO,QAAQ;AACjC,QAAI,CAAC,MAAM,IAAI;AACb;AAAA,IACF;AACA,WAAO,QAAQ,KAAK,cAAc,KAAK,CAAC;AAAA,EAC1C;AAEA,QAAM,mBACH,SAAK,QAAQ,EAAC,yBAAyB,KAAI,CAAC,EAC5C,KAAK;AACR,MAAI,OAAO,WAAW,eAAe,GAAG;AACtC,UAAM,WAAe,WAAO,mBAAmB,YAAY;AAC3D,aAAS,cAAc,KAAS,WAAO,mBAAmB,eAAe,CAAC;AAC1E,UAAM,UAAc,WAAO;AAAA,MACzB,GAAG,EAAE;AAAA,MACL;AAAA,MACI,qBAAiB;AAAA,IACvB;AACA,YAAQ,eAAe;AAEvB,UAAM,gBACH,SAAK,SAAS,EAAC,yBAAyB,KAAI,CAAC,EAC7C,KAAK;AACR,WAAO,SAAS,mBAAmB,SAAS,aAAa;AAAA,EAC3D;AACA,SAAO,SAAS,gBAAgB;AAClC;AAKA,SAAS,SAAS,OAAuB;AACvC,QAAM,QAAQ,MAAM,MAAM,IAAI;AAC9B,QAAM,UAAoB,CAAC;AAC3B,aAAW,QAAQ,OAAO;AACxB,UAAM,gBAAgB,KAAK,QAAQ,SAAS,IAAI;AAChD,YAAQ,KAAK,aAAa;AAAA,EAC5B;AACA,SAAO,QAAQ,KAAK,IAAI;AAC1B;AAKA,SAAS,aAAa,OAAuB;AAC3C,SAAO,MAAM,QAAQ,iBAAiB,EAAE;AAC1C;AAjOA,IASM,WAgBA;AAzBN;AAAA;AAAA;AASA,IAAM,YAAYA,MAAK,QAAQ,cAAc,YAAY,GAAG,CAAC;AAgB7D,IAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACzBjB,SAAQ,YAAYC,WAAS;AAC7B,OAAOC,WAAU;AACjB,SAAQ,iBAAAC,sBAAoB;AAU5B,OAAO,gBAAgB;AACvB;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAQ,eAA8B;AACtC,SAAmB,oBAAmB;AACtC,YAAY,kBAAkB;AAC9B,OAAO,UAAU;;;ACrBjB,SAAQ,2BAA0B;;;ACDlC,OAAO,YAAY;AACnB,SAAQ,gBAAe;AACvB,SAAQ,uBAAsB;AAC9B,SAAQ,gBAAe;AACvB,SAAQ,oBAAoB,4BAA2B;AACvD,SAAQ,iBAAgB;AAIxB,IAAI,qBAAqB;AAUlB,IAAM,OAAN,MAAW;AAAA,EAQhB,YACE,YACA,IACA,SACA;AA/BJ;AAgCI,SAAK,aAAa;AAClB,SAAK,YAAY,WAAW;AAC5B,SAAK,mBAAmB,KAAK,UAAU,UAAU,UAAU;AAC3D,SAAK,KAAK;AACV,SAAK,UAAU,mCAAS;AACxB,SAAK,QAAQ,mCAAS;AACtB,QAAI,CAAC,KAAK,OAAO;AACf,UAAI,SAAO,UAAK,iBAAiB,gBAAtB,mBAAmC,QAAO,UAAU;AAC7D,YAAI,KAAK,iBAAiB,YAAY,GAAG,OAAO;AAC9C,eAAK,QAAQ,KAAK,iBAAiB,YAAY,GAAG;AAAA,QACpD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,QAA0D;AACzE,QAAI,CAAC,oBAAoB;AACvB,YAAM,iBAAiB,KAAK,iBAAiB;AAC7C,sBAAgB;AAAA,QACd,SAAS;AAAA,UACP,SAAS;AAAA,YACP,WAAW,eAAe;AAAA;AAAA,YAE1B,UAAU,eAAe,YAAY;AAAA,UACvC,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AACD,2BAAqB;AAAA,IACvB;AAEA,QAAI,QAAQ;AACZ,QAAI,KAAK,UAAU,kBAAkB;AACnC,cAAQ;AAAA,IACV;AAEA,QAAI,CAAC,KAAK,SAAS;AAEjB,YAAM,KAAK,YAAY;AAAA,IACzB;AAMA,UAAM,MAAM,MAAM,SAAS;AAAA,MACzB;AAAA,MACA;AAAA,MACA,SAAS,KAAK;AAAA,IAChB,CAAC;AACD,YAAQ,IAAI,IAAI,KAAK,CAAC;AACtB,UAAM,UAAU,IAAI,UAAU;AAC9B,SAAK,UAAU;AACf,UAAM,KAAK,MAAM,EAAE,OAAO,EAAC,SAAS,YAAY,UAAU,IAAI,EAAC,CAAC;AAChE,WAAO,IAAI,KAAK;AAAA,EAClB;AAAA,EAEA,QAAQ;AACN,WAAO,KAAK,WAAW,aAAa,EAAE,IAAI,KAAK,EAAE;AAAA,EACnD;AAAA,EAEA,MAAM,cAAc;AAClB,UAAM,aAAa;AAAA,MACjB,6FACE,KAAK,iBAAiB,QAAQ,KAAK,iBAAiB,EACtD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,KAAK,UAAU,KAAK,UAAU,YAAY,MAAM,CAAC;AAAA,MACjD;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAGA,UAAM,QAAQ,MAAM,KAAK,UAAU,SAAS,SAAS,EAAC,MAAM,QAAO,CAAC;AACpE,UAAM,KAAK,QAAQ,CAAC,QAAa;AAC/B,iBAAW,KAAK,KAAK,UAAU,GAAG,CAAC;AAAA,IACrC,CAAC;AAED,SAAK,UAAU,CAAC,EAAC,MAAM,UAAU,SAAS,CAAC,EAAC,MAAM,WAAW,KAAK,IAAI,EAAC,CAAC,EAAC,CAAC;AAC1E,YAAQ,IAAI,KAAK,OAAO;AAAA,EAC1B;AACF;AAEO,IAAM,aAAN,MAAiB;AAAA,EAItB,YAAY,WAA0B,MAAc;AAClD,SAAK,YAAY;AACjB,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,MAAM,WAAW,SAA2C;AAC1D,UAAM,SAAS,OAAO,WAAW;AAGjC,UAAM,SAAS,KAAK,aAAa,EAAE,IAAI,MAAM;AAC7C,UAAM,OAAO,IAAI;AAAA,MACf,IAAI;AAAA,MACJ,WAAW,KAAK;AAAA,MAChB,WAAW,UAAU,IAAI;AAAA,MACzB,YAAY,UAAU,IAAI;AAAA,MAC1B,QAAO,mCAAS,UAAS;AAAA,IAC3B,CAAC;AACD,WAAO,IAAI,KAAK,MAAM,MAAM;AAAA,EAC9B;AAAA,EAEA,MAAM,QAAQ,QAA+B;AAE3C,UAAM,SAAS,KAAK,aAAa,EAAE,IAAI,MAAM;AAC7C,UAAM,UAAU,MAAM,OAAO,IAAI;AACjC,QAAI,CAAC,QAAQ,QAAQ;AACnB,YAAM,IAAI,MAAM,GAAG,MAAM,iBAAiB;AAAA,IAC5C;AACA,UAAM,WAAW,QAAQ,KAAK,KAAK,CAAC;AACpC,WAAO,IAAI,KAAK,MAAM,QAAQ;AAAA,MAC5B,SAAS,SAAS;AAAA,MAClB,OAAO,SAAS;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,UAAU,SAA4C;AAC1D,UAAM,SAAQ,mCAAS,UAAS;AAChC,UAAM,QAAQ,KAAK,aAAa,EAC7B,MAAM,aAAa,MAAM,KAAK,IAAI,EAClC,MAAM,KAAK,EACX,QAAQ,aAAa,MAAM;AAC9B,UAAM,MAAM,MAAM,MAAM,IAAI;AAC5B,WAAO,IAAI,KAAK,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC;AAAA,EACzC;AAAA,EAEA,eAAe;AACb,WAAO,KAAK,UAAU,GAAG;AAAA,MACvB,YAAY,KAAK,UAAU,SAAS;AAAA,IACtC;AAAA,EACF;AACF;;;AC1KA,OAAOC,aAAY;AAGnB;AAAA,EACE;AAAA,EAGA,aAAAC;AAAA,OAEK;AA+LA,IAAM,gBAAN,MAAoB;AAAA,EAOzB,YAAY,YAAwB;AAClC,SAAK,aAAa;AAClB,SAAK,YAAY,aAAa,KAAK,UAAU;AAE7C,UAAM,mBAAmB,KAAK,UAAU,UAAU;AAClD,SAAK,YAAY,iBAAiB,MAAM;AACxC,SAAK,MAAM,KAAK,UAAU,eAAe;AACzC,SAAK,KAAK,KAAK,UAAU,aAAa;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,OACJ,cACA,MACA,SAC6B;AAC7B,UAAM,UAAU,MAAM,KAAK,UAAU,cAAc,MAAM,OAAO;AAChE,QAAI,SAAS;AACX,aAAO,cAAc,OAAO;AAAA,IAC9B;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UACJ,cACA,MACA,SACqB;AACrB,UAAM,OAAO,QAAQ;AACrB,UAAM,SAAS,KAAK,SAAS,cAAc,MAAM,EAAC,KAAI,CAAC;AACvD,UAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAI,IAAI,QAAQ;AACd,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAAA,EAEA,qBACE,cACA,SACA;AACA,QAAI,iBAAiB;AACrB,QAAI,QAAQ,SAAS,SAAS;AAC5B,uBAAiB;AAAA,IACnB,WAAW,QAAQ,SAAS,aAAa;AACvC,uBAAiB;AAAA,IACnB,OAAO;AACL,YAAM,IAAI,MAAM,iBAAiB,QAAQ,IAAI,EAAE;AAAA,IACjD;AACA,WAAO,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc;AAAA,EACjF;AAAA,EAEA,UACE,cACA,MACA,SACA;AACA,UAAM,qBAAqB,KAAK,qBAAqB,cAAc,OAAO;AAE1E,UAAM,iBAAiB,KAAK,WAAW,KAAK,IAAI;AAChD,WAAO,GAAG,kBAAkB,IAAI,cAAc;AAAA,EAChD;AAAA,EAEA,SACE,cACA,MACA,SACA;AACA,UAAM,UAAU,KAAK,UAAU,cAAc,MAAM,OAAO;AAC1D,WAAO,KAAK,GAAG,IAAI,OAAO;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAM,cACJ,OACA,YACA,SACA;AACA,UAAM,EAAC,YAAY,KAAI,IAAI,WAAW,KAAK;AAC3C,UAAM,WACH,MAAM,KAAK,UAAU,YAAY,MAAM,EAAC,MAAM,QAAO,CAAC,KAAM,CAAC;AAChE,UAAM,WAAW,SAAS,OAAO,CAAC;AAClC,UAAM,cAAa,mCAAS,eAAc;AAC1C,UAAM,SAAS,YAAY,cAAc,CAAC,CAAC;AAC3C,UAAM,OAAO;AAAA,MACX,IAAI;AAAA,MACJ;AAAA,MACA;AAAA,MACA,KAAK;AAAA,QACH,GAAG;AAAA,QACH,WAAW,SAAS,aAAaC,WAAU,IAAI;AAAA,QAC/C,WAAW,SAAS,aAAa;AAAA,QACjC,YAAYA,WAAU,IAAI;AAAA,QAC1B;AAAA,QACA,UAAS,mCAAS,YAAW,SAAS,WAAW,CAAC,IAAI;AAAA,MACxD;AAAA,MACA;AAAA,IACF;AACA,UAAM,KAAK,UAAU,YAAY,MAAM,MAAM,EAAC,MAAM,QAAO,CAAC;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UACJ,cACA,MACA,MACA,SACA;AACA,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc,IAAI,IAAI;AAC/F,UAAM,SAAS,KAAK,GAAG,IAAI,MAAM;AACjC,UAAM,OAAO,IAAI,IAAI;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,SACJ,cACA,SACsB;AACtB,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc;AACvF,QAAI,QAAe,KAAK,GAAG,WAAW,MAAM;AAC5C,QAAI,QAAQ,OAAO;AACjB,cAAQ,MAAM,MAAM,QAAQ,KAAK;AAAA,IACnC;AACA,QAAI,QAAQ,QAAQ;AAClB,cAAQ,MAAM,OAAO,QAAQ,MAAM;AAAA,IACrC;AACA,QAAI,QAAQ,SAAS;AACnB,cAAQ,MAAM,QAAQ,QAAQ,SAAS,QAAQ,gBAAgB;AAAA,IACjE;AACA,QAAI,QAAQ,OAAO;AACjB,cAAQ,QAAQ,MAAM,KAAK;AAAA,IAC7B;AACA,UAAM,UAAU,MAAM,MAAM,IAAI;AAChC,UAAM,OAAY,CAAC;AACnB,YAAQ,QAAQ,CAAC,WAAW;AAC1B,UAAI,QAAQ,KAAK;AAGf,cAAM,SAAS,OAAO,KAAK;AAC3B,aAAK,KAAK,MAAM;AAAA,MAClB,OAAO;AACL,cAAM,MAAM,cAAc,OAAO,KAAK,CAAC;AACvC,aAAK,KAAK,GAAG;AAAA,MACf;AAAA,IACF,CAAC;AACD,WAAO,EAAC,KAAI;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAAa,cAAsB,SAA0B;AACjE,UAAM,OAAO,QAAQ;AACrB,UAAM,iBAAiB,SAAS,UAAU,WAAW;AACrD,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,IAAI,cAAc;AACvF,QAAI,QAAe,KAAK,GAAG,WAAW,MAAM;AAC5C,QAAI,QAAQ,OAAO;AACjB,cAAQ,QAAQ,MAAM,KAAK;AAAA,IAC7B;AACA,UAAM,UAAU,MAAM,MAAM,MAAM,EAAE,IAAI;AACxC,UAAM,QAAQ,QAAQ,KAAK,EAAE;AAC7B,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,YACJ,QACA,SACA;AACA,UAAM,yBAAyB,YAAY,KAAK,SAAS;AACzD,UAAM,eAAc,mCAAS,gBAAe;AAG5C,UAAM,UAAU,OAAO,IAAI,CAAC,UAAU;AACpC,YAAM,CAAC,YAAY,IAAI,IAAI,MAAM,MAAM,GAAG;AAC1C,UAAI,CAAC,cAAc,CAAC,MAAM;AACxB,cAAM,IAAI,MAAM,mBAAmB,KAAK,EAAE;AAAA,MAC5C;AACA,YAAM,SAAS,KAAK,GAAG;AAAA,QACrB,GAAG,sBAAsB,IAAI,UAAU,WAAW,IAAI;AAAA,MACxD;AACA,aAAO;AAAA,IACT,CAAC;AACD,UAAM,eAAe,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO;AACpD,UAAM,OAAO,aAEV,IAAI,CAAC,aAAa,SAAS,KAAK,CAAQ,EAExC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;AAEpB,QAAI,KAAK,WAAW,GAAG;AACrB,cAAQ,IAAI,oBAAoB;AAChC,aAAO,CAAC;AAAA,IACV;AAGA,eAAW,OAAO,MAAM;AACtB,UAAI,KAAK,qBAAqB,GAAG,GAAG;AAClC,cAAM,IAAI,MAAM,iCAAiC,IAAI,EAAE,EAAE;AAAA,MAC3D;AAAA,IACF;AAIA,QAAI,aAAa;AACjB,UAAM,SAAQ,mCAAS,UAAS,KAAK,GAAG,MAAM;AAC9C,UAAM,gBAAuB,CAAC;AAC9B,eAAW,OAAO,MAAM;AACtB,YAAM,EAAC,IAAI,YAAY,MAAM,KAAK,OAAM,IAAI;AAC5C,YAAM,WAAW,KAAK,GAAG;AAAA,QACvB,GAAG,sBAAsB,IAAI,UAAU,WAAW,IAAI;AAAA,MACxD;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAI,UAAU,cAAc,IAAI;AAAA,MAC3D;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAI,UAAU,cAAc,IAAI;AAAA,MAC3D;AAGA,YAAM,mBACJ,IAAI,oBAAoB,WAAW,gBAAgB;AACrD,YAAM,mBAAmB,IAAI,oBAAoB;AAGjD,YAAM,IAAI,cAAc;AAAA,QACtB;AAAA,QACA;AAAA,QACA;AAAA,QACA,QAAQ,UAAU,CAAC;AAAA,QACnB,KAAK;AAAA,UACH,GAAG;AAAA,UACH;AAAA,UACA;AAAA,UACA,aAAa,WAAW,gBAAgB;AAAA,UACxC;AAAA,QACF;AAAA,MACF,CAAC;AACD,oBAAc;AAGd,YAAM,OAAO,YAAY;AACzB,oBAAc;AAId,YAAM,OAAO,UAAU;AAAA,QACrB,mBAAmB,WAAW,OAAO;AAAA,QACrC,mBAAmB,WAAW,OAAO;AAAA,QACrC,wBAAwB;AAAA,QACxB,wBAAwB;AAAA,QACxB,mBAAmB,WAAW,gBAAgB;AAAA,QAC9C,mBAAmB;AAAA,MACrB,CAAC;AACD,oBAAc;AAEd,WAAK,uBAAuB,IAAI,IAAI,EAAC,MAAK,CAAC;AAC3C,oBAAc;AAEd,oBAAc,KAAK,GAAG;AAEtB,UAAI,cAAc,KAAK;AACrB,cAAM,MAAM,OAAO;AACnB,qBAAa;AAAA,MACf;AAAA,IACF;AAEA,QAAI,aAAa,GAAG;AAClB,YAAM,MAAM,OAAO;AAAA,IACrB;AACA,YAAQ,IAAI,aAAa,cAAc,MAAM,QAAQ;AACrD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,uBAAuB;AAC3B,UAAM,yBAAyB,YAAY,KAAK,SAAS;AACzD,UAAM,MAAM,KAAK,MAAK,oBAAI,KAAK,GAAE,QAAQ,CAAC;AAE1C,UAAM,WAAW,MAAM,KAAK,GAAG,gBAAgB,WAAW,EAAE,IAAI;AAChE,UAAM,OAAO,SAAS,KACnB,OAAO,CAAC,MAAM;AAhgBrB;AAkgBQ,UAAI,CAAC,EAAE,IAAI,KAAK,WAAW,sBAAsB,GAAG;AAClD,eAAO;AAAA,MACT;AAIA,YAAM,OAAO,EAAE,KAAK,KAAK,CAAC;AAC1B,YAAM,eAAqC,UAAK,QAAL,mBAAU;AACrD,aACE,eAAe,YAAY,YAAY,YAAY,SAAS,KAAK;AAAA,IAErE,CAAC,EACA,IAAI,CAAC,MAAM;AACV,YAAM,SAAS,EAAE,IAAI;AACrB,YAAM,WAAW,OAAO,MAAM,GAAG;AACjC,YAAM,OAAO,SAAS,GAAG,EAAE;AAC3B,YAAM,aAAa,SAAS,GAAG,EAAE;AACjC,YAAM,KAAK,GAAG,UAAU,IAAI,IAAI;AAChC,aAAO;AAAA,QACL,MAAM,EAAE,KAAK;AAAA,QACb;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAEH,QAAI,KAAK,WAAW,GAAG;AACrB,cAAQ,IAAI,qBAAqB;AACjC,aAAO,CAAC;AAAA,IACV;AAIA,QAAI,aAAa;AACjB,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,UAAM,gBAAuB,CAAC;AAC9B,eAAW,OAAO,MAAM;AACtB,YAAM,EAAC,IAAI,YAAY,MAAM,KAAI,IAAI;AACrC,YAAM,WAAW,KAAK,GAAG;AAAA,QACvB,GAAG,sBAAsB,IAAI,UAAU,WAAW,IAAI;AAAA,MACxD;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAI,UAAU,cAAc,IAAI;AAAA,MAC3D;AACA,YAAM,eAAe,KAAK,GAAG;AAAA,QAC3B,GAAG,sBAAsB,IAAI,UAAU,cAAc,IAAI;AAAA,MAC3D;AACA,YAAM,EAAC,aAAa,aAAa,GAAG,IAAG,IAAI,KAAK,OAAO,CAAC;AAGxD,YAAM,mBAAmB,IAAI,oBAAoB;AACjD,YAAM,mBACJ,IAAI,qBAAqB,eAAe;AAG1C,YAAM,IAAI,cAAc;AAAA,QACtB;AAAA,QACA;AAAA,QACA;AAAA,QACA,QAAQ,KAAK,UAAU,CAAC;AAAA,QACxB,KAAK;AAAA,UACH,GAAG;AAAA,UACH;AAAA,UACA;AAAA,UACA,aAAa,WAAW,gBAAgB;AAAA,UACxC,aAAa,eAAe;AAAA,QAC9B;AAAA,MACF,CAAC;AACD,oBAAc;AAGd,YAAM,OAAO,YAAY;AACzB,oBAAc;AAId,YAAM,OAAO,UAAU;AAAA,QACrB,mBAAmB,WAAW,OAAO;AAAA,QACrC,mBAAmB,WAAW,OAAO;AAAA,QACrC,wBAAwB;AAAA,QACxB,wBAAwB;AAAA,QACxB,mBAAmB,WAAW,gBAAgB;AAAA,QAC9C,mBAAmB,eAAe;AAAA,MACpC,CAAC;AACD,oBAAc;AAEd,WAAK,uBAAuB,IAAI,IAAI,EAAC,MAAK,CAAC;AAC3C,oBAAc;AAEd,oBAAc,KAAK,GAAG;AAEtB,UAAI,cAAc,KAAK;AACrB,cAAM,MAAM,OAAO;AACnB,qBAAa;AACb;AAAA,MACF;AAAA,IACF;AAEA,QAAI,aAAa,GAAG;AAClB,YAAM,MAAM,OAAO;AAAA,IACrB;AACA,YAAQ,IAAI,aAAa,cAAc,MAAM,QAAQ;AACrD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,2BAA2B;AAC/B,UAAM,eAAe,YAAY,KAAK,SAAS;AAC/C,UAAM,MAAM,KAAK,MAAK,oBAAI,KAAK,GAAE,QAAQ,CAAC;AAC1C,UAAM,QAAe,KAAK,GACvB,WAAW,YAAY,EACvB,MAAM,eAAe,MAAMA,WAAU,WAAW,GAAG,CAAC;AACvD,UAAM,gBAAgB,MAAM,MAAM,IAAI;AAEtC,eAAW,YAAY,cAAc,MAAM;AACzC,YAAM,UAAU,SAAS,KAAK;AAC9B,YAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,YAAM,cAAc,QAAQ,eAAe;AAC3C,YAAM,OAAO,SAAS,KAAK;AAAA,QACzB,aAAaA,WAAU,IAAI;AAAA,QAC3B;AAAA,QACA,aAAa,WAAW,OAAO;AAAA,QAC/B,aAAa,WAAW,OAAO;AAAA,MACjC,CAAC;AACD,YAAM,KAAK,YAAY,QAAQ,UAAU,CAAC,GAAG,EAAC,aAAa,MAAK,CAAC;AAAA,IACnE;AAAA,EACF;AAAA,EAEA,MAAM,uBACJ,gBACA,SACA;AACA,UAAM,UAAU,eAAe,WAAW,KAAK,IAAI;AACnD,UAAM,WAAW,KAAK,GAAG;AAAA,MACvB,YAAY,KAAK,SAAS,2CAA2C,OAAO;AAAA,IAC9E;AACA,UAAM,WAAW,MAAM,SAAS,IAAI;AAEpC,QAAI,CAAC,SAAS,QAAQ;AAEpB,cAAQ,KAAK,gBAAgB,cAAc,iBAAiB;AAC5D;AAAA,IACF;AAIA,UAAM,cAAc,EAAC,mCAAS;AAE9B,UAAM,SAAQ,mCAAS,UAAS,KAAK,GAAG,MAAM;AAC9C,UAAM,OAAO,UAAU;AAAA,MACrB,mBAAmBA,WAAU,IAAI;AAAA,MACjC,oBAAmB,mCAAS,gBAAe;AAAA,IAC7C,CAAC;AAED,UAAM,eAAe,KAAK,GAAG;AAAA,MAC3B,YAAY,KAAK,SAAS,+CAA+C,OAAO;AAAA,IAClF;AACA,UAAM,OAAO,EAAC,GAAG,SAAS,KAAK,EAAC;AAChC,QAAI,CAAC,KAAK,KAAK;AACb,WAAK,MAAM,CAAC;AAAA,IACd;AACA,SAAK,IAAI,cAAcA,WAAU,IAAI;AACrC,SAAK,IAAI,eAAc,mCAAS,gBAAe;AAC/C,UAAM,IAAI,cAAc,IAAI;AAC5B,QAAI,aAAa;AACf,YAAM,MAAM,OAAO;AACnB,WAAK,UAAU,wBAAwB,EAAC,UAAU,EAAC,eAAc,EAAC,CAAC;AAAA,IACrE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,qBAAqB,KAAU;AAjrBjC;AAkrBI,SAAI,SAAI,QAAJ,mBAAS,kBAAkB;AAC7B,UAAI,IAAI,IAAI,iBAAiB,OAAO;AAClC,cAAM,MAAMA,WAAU,IAAI,EAAE,SAAS;AACrC,cAAM,QAAQ,IAAI,IAAI,iBAAiB,MAAM,SAAS;AACtD,eAAO,MAAM;AAAA,MACf;AACA,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,iBACJ,SAC0B;AAC1B,UAAM,SAAS,YAAY,KAAK,SAAS;AACzC,UAAM,kBAAmC,CAAC;AAE1C,UAAM,kBAAkB,CAAC,MAAc,iBAA8B;AACnE,sBAAgB,IAAI,IAAI,OAAO;AAAA,QAC7B,gBAAgB,IAAI,KAAK,CAAC;AAAA,QAC1B;AAAA,MACF;AAAA,IACF;AAEA,QAAI,QAAe,KAAK,GAAG,WAAW,MAAM;AAC5C,SAAI,mCAAS,SAAQ,QAAQ,KAAK,SAAS,GAAG;AAC5C,cAAQ,MAAM,MAAM,YAAY,sBAAsB,QAAQ,IAAI;AAAA,IACpE;AACA,UAAM,WAAW,MAAM,MAAM,IAAI;AACjC,aAAS,QAAQ,CAAC,QAAQ;AACxB,YAAM,OAAO,IAAI,KAAK;AACtB,YAAM,UAAW,KAAK,WAAW,CAAC;AAClC,aAAO,QAAQ,OAAO,EAAE,QAAQ,CAAC,CAAC,MAAM,YAAY,MAAM;AACxD,wBAAgB,MAAM,YAAY;AAAA,MACpC,CAAC;AAAA,IACH,CAAC;AAED,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,sBACJ,gBACA,cACA,SACA;AACA,UAAM,UAAU,eAAe,WAAW,KAAK,IAAI;AACnD,UAAM,UAAU,YAAY,KAAK,SAAS,8BAA8B,OAAO;AAC/E,UAAM,SAAS,KAAK,GAAG,IAAI,OAAO;AAElC,UAAM,WAAW,MAAM,OAAO,IAAI;AAClC,UAAM,OAAO,SAAS,KAAK,KAAK;AAAA,MAC9B,IAAI,eAAe,WAAW,MAAM,GAAG;AAAA,MACvC,KAAK,CAAC;AAAA,MACN,SAAS,CAAC;AAAA,IACZ;AACA,SAAK,IAAI,aAAaA,WAAU,IAAI;AACpC,SAAK,IAAI,cAAa,mCAAS,eAAc;AAE7C,UAAM,UAAU,KAAK,WAAW,CAAC;AACjC,WAAO,QAAQ,YAAY,EAAE,QAAQ,CAAC,CAAC,QAAQ,GAAG,MAAM;AACtD,YAAM,mBAAmB,KAAK,gBAAgB,MAAM;AACpD,YAAM,OAAO,KAAK,kBAAkB,gBAAgB;AACpD,cAAQ,IAAI,IAAI,EAAC,GAAG,QAAQ,IAAI,GAAG,GAAG,KAAK,QAAQ,iBAAgB;AAAA,IACrE,CAAC;AACD,SAAK,UAAU;AACf,UAAM,OAAO,IAAI,IAAI;AACrB,SAAK,UAAU,qBAAqB,EAAC,UAAU,EAAC,eAAc,EAAC,CAAC;AAAA,EAClE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,kBAAkB,QAAgB;AAChC,UAAM,OAAOC,QACV,WAAW,MAAM,EACjB,OAAO,KAAK,gBAAgB,MAAM,CAAC,EACnC,OAAO,KAAK;AACf,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,gBAAgB,KAAa;AAC3B,UAAM,QAAQ,OAAO,GAAG,EACrB,KAAK,EACL,MAAM,IAAI,EACV,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC;AAC/B,WAAO,MAAM,KAAK,IAAI;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,0BACJ,QACA,SAC6B;AAC7B,UAAM,kBAAkB,MAAM,KAAK,iBAAiB,OAAO;AAC3D,WAAO,sBAAsB,iBAAiB,MAAM;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,cAAc,cAAsB;AACxC,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY;AACrE,UAAM,SAAS,KAAK,GAAG,IAAI,MAAM;AACjC,UAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAI,IAAI,QAAQ;AACd,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,eAAe,cAAsB,SAA+B;AACxE,UAAM,aAAa,MAAM,KAAK,cAAc,YAAY;AACxD,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,0BAA0B,YAAY,EAAE;AAAA,IAC1D;AAEA,UAAM,OAAO,MAAM,KAAK,UAAU,UAAU;AAE5C,UAAM,mBAAmB,KAAK,GAAG;AAAA,MAC/B,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,aAAa,KAAK,GAAG;AAAA,MACzB,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,YAAW,mCAAS,aAAY;AAEtC,UAAM,oBAAgC;AAAA,MACpC,GAAG;AAAA,MACH,UAAUD,WAAU,IAAI;AAAA,MACxB;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,UAAM,IAAI,YAAY;AAAA,MACpB,YAAY;AAAA,MACZ;AAAA,IACF,CAAC;AACD,UAAM,OAAO,kBAAkB;AAAA,MAC7B,UAAUA,WAAU,IAAI;AAAA,MACxB;AAAA,IACF,CAAC;AACD,UAAM,MAAM,OAAO;AAEnB,YAAQ,IAAI,uBAAuB,YAAY,EAAE;AACjD,YAAQ,IAAI,cAAc,QAAQ,EAAE;AAAA,EACtC;AAAA,EAEA,MAAM,kBACJ,cACA,SACA;AACA,UAAM,aAAa,MAAM,KAAK,cAAc,YAAY;AACxD,QAAI,CAAC,YAAY;AACf,YAAM,IAAI,MAAM,0BAA0B,YAAY,EAAE;AAAA,IAC1D;AAEA,UAAM,mBAAmB,KAAK,GAAG;AAAA,MAC/B,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,kBAAkB,KAAK,GAAG;AAAA,MAC9B,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AACA,UAAM,sBAAsB,KAAK,GAAG;AAAA,MAClC,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAAA,IACxD;AAEA,UAAM,UAAU,MAAM,KAAK,kBAAkB,cAAc,EAAC,MAAM,QAAO,CAAC;AAE1E,UAAM,eAAc,mCAAS,gBAAe;AAE5C,UAAM,oBAAgC;AAAA,MACpC,GAAG;AAAA,MACH,aAAaA,WAAU,IAAI;AAAA,MAC3B;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,UAAM,IAAI,qBAAqB;AAAA,MAC7B,YAAY;AAAA,MACZ,OAAM,mCAAS,SAAQ;AAAA,IACzB,CAAC;AACD,UAAM,OAAO,iBAAiB;AAAA,MAC5B,YAAY;AAAA,IACd,CAAC;AACD,UAAM,OAAO,kBAAkB;AAAA,MAC7B,aAAaA,WAAU,IAAI;AAAA,MAC3B;AAAA,IACF,CAAC;AACD,UAAM,MAAM,OAAO;AAEnB,YAAQ,IAAI,kBAAkB,YAAY,EAAE;AAC5C,YAAQ,IAAI,iBAAiB,WAAW,EAAE;AAAA,EAC5C;AAAA,EAEA,MAAc,UAAU,YAAwB;AAC9C,QAAI,WAAW,SAAS,QAAQ;AAC9B,aAAO,MAAM,KAAK,cAAc,UAAU;AAAA,IAC5C;AAKA,UAAM,IAAI,MAAM,4BAA4B,WAAW,IAAI,EAAE;AAAA,EAC/D;AAAA,EAEA,MAAc,cAAc,YAAwB;AA55BtD;AA65BI,UAAM,MAAM,WAAW,OAAO;AAC9B,QAAI,CAAC,IAAI,WAAW,UAAU,GAAG;AAC/B,YAAM,IAAI,MAAM,sBAAsB,GAAG,EAAE;AAAA,IAC7C;AAEA,UAAM,MAAM,MAAM,MAAM,KAAK;AAAA,MAC3B,UAAQ,gBAAW,gBAAX,mBAAwB,WAAU;AAAA,MAC1C,WAAS,gBAAW,gBAAX,mBAAwB,YAAW,CAAC;AAAA,MAC7C,QAAM,gBAAW,gBAAX,mBAAwB,SAAQ;AAAA,IACxC,CAAC;AAED,QAAI,IAAI,WAAW,KAAK;AACtB,YAAM,MAAM,MAAM,IAAI,KAAK;AAC3B,YAAM,IAAI,MAAM,eAAe,GAAG,EAAE;AAAA,IACtC;AAEA,UAAM,cAAc,OAAO,IAAI,QAAQ,IAAI,cAAc,CAAC;AAC1D,QAAI,YAAY,SAAS,kBAAkB,GAAG;AAC5C,aAAO,MAAM,IAAI,KAAK;AAAA,IACxB;AACA,WAAO,IAAI,KAAK;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,kBACJ,cACA,SACmC;AACnC,UAAM,QAAO,mCAAS,SAAQ;AAE9B,UAAM,SAAS,KAAK,oBAAoB,cAAc,EAAC,KAAI,CAAC;AAC5D,UAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAI,IAAI,QAAQ;AACd,aAAO,IAAI,KAAK;AAAA,IAClB;AACA,WAAO;AAAA,EACT;AAAA,EAEA,qBACE,cACA,SACA;AACA,QAAI,CAAC,gBAAgB,aAAa,SAAS,GAAG,GAAG;AAC/C,YAAM,IAAI,MAAM,2BAA2B,YAAY,EAAE;AAAA,IAC3D;AACA,UAAM,OAAO,QAAQ;AACrB,QAAI,EAAE,SAAS,WAAW,SAAS,cAAc;AAC/C,YAAM,IAAI,MAAM,iBAAiB,IAAI,EAAE;AAAA,IACzC;AACA,UAAM,SAAS,YAAY,KAAK,SAAS,gBAAgB,YAAY,SAAS,IAAI;AAClF,WAAO;AAAA,EACT;AAAA,EAEA,oBACE,cACA,SACA;AACA,UAAM,SAAS,KAAK,qBAAqB,cAAc,OAAO;AAC9D,WAAO,KAAK,GAAG,IAAI,MAAM;AAAA,EAC3B;AAAA,EAEA,mBACE,gBACA,SACA;AACA,UAAM,OAAO,QAAQ;AACrB,QAAI,EAAE,SAAS,WAAW,SAAS,cAAc;AAC/C,YAAM,IAAI,MAAM,iBAAiB,IAAI,EAAE;AAAA,IACzC;AACA,UAAM,OAAO,eAAe,WAAW,KAAK,IAAI;AAChD,UAAM,SAAS,YAAY,KAAK,SAAS,wBAAwB,IAAI,iBAAiB,IAAI;AAC1F,WAAO;AAAA,EACT;AAAA,EAEA,kBACE,gBACA,SACA;AACA,UAAM,SAAS,KAAK,mBAAmB,gBAAgB,OAAO;AAC9D,WAAO,KAAK,GAAG,IAAI,MAAM;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,YAAY,OAAyC;AACzD,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AACA,UAAM,SAAS,KAAK,GAAG,IAAI,YAAY,KAAK,SAAS,EAAE;AACvD,UAAM,WAAW,MAAM,OAAO,IAAI;AAClC,UAAM,OAAO,SAAS,KAAK,KAAK,CAAC;AACjC,UAAM,MAAM,KAAK,SAAS,CAAC;AAE3B,QAAI,SAAS,KAAK;AAChB,aAAO,IAAI,KAAK;AAAA,IAClB;AAGA,QAAI,CAAC,MAAM,SAAS,GAAG,GAAG;AACxB,cAAQ,KAAK,kBAAkB,KAAK,EAAE;AACtC,aAAO;AAAA,IACT;AACA,UAAM,SAAS,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE;AACrC,QAAI,UAAU,KAAK,MAAM,MAAM,KAAK;AAClC,aAAO,IAAI,KAAK,MAAM,EAAE;AAAA,IAC1B;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,gBAAgB,OAAiC;AACrD,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AACA,UAAM,SAAS,KAAK,GAAG,IAAI,YAAY,KAAK,SAAS,EAAE;AACvD,UAAM,WAAW,MAAM,OAAO,IAAI;AAClC,UAAM,OAAO,SAAS,KAAK,KAAK,CAAC;AACjC,UAAM,MAAM,KAAK,SAAS,CAAC;AAC3B,QAAI,SAAS,KAAK;AAChB,aAAO;AAAA,IACT;AAGA,QAAI,CAAC,MAAM,SAAS,GAAG,GAAG;AACxB,cAAQ,KAAK,kBAAkB,KAAK,EAAE;AACtC,aAAO;AAAA,IACT;AACA,UAAM,SAAS,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE;AACrC,QAAI,UAAU,KAAK,MAAM,MAAM,KAAK;AAClC,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,UAAU,QAAgB,SAAyC;AACvE,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI,MAAM,4BAA4B;AAAA,IAC9C;AACA,UAAM,OAAO;AAAA,MACX;AAAA,MACA,WAAWA,WAAU,IAAI;AAAA,MACzB,KAAI,mCAAS,OAAM;AAAA,MACnB,WAAU,mCAAS,aAAY,CAAC;AAAA,IAClC;AACA,UAAM,SAAS,KAAK,GAAG,WAAW,YAAY,KAAK,SAAS,aAAa;AACzE,UAAM,OAAO,IAAI,IAAI;AAErB,UAAM,WAAU,mCAAS,YAAW,aAAa,QAAQ,QAAQ,IAAI;AACrE,YAAQ,IAAI,IAAI,KAAK,UAAU,SAAS,CAAC,aAAa,MAAM,IAAI,OAAO,EAAE;AAGzE,UAAM,kBAAkB,KAAK,UAAU,UAAU;AACjD,QAAI,gBAAgB,UAAU;AAC5B,UAAI;AACF,wBAAgB,SAAS,IAAI;AAAA,MAC/B,SAAS,KAAK;AACZ,gBAAQ,MAAM,GAAG;AAAA,MACnB;AAAA,IACF;AAAA,EACF;AAAA,EAEA,mBAAmB,SAA4C;AAC7D,WAAO,IAAI,aAAa,MAAM,OAAO;AAAA,EACvC;AACF;AAyBO,IAAM,eAAN,MAAmB;AAAA,EASxB,YAAY,WAA0B,SAA8B;AALpE,SAAQ,SAAmB,CAAC;AAC5B,SAAQ,gBAA0B,CAAC;AACnC,SAAQ,UAA+B,CAAC;AACxC,SAAQ,kBAA4B,CAAC;AAGnC,SAAK,YAAY;AACjB,SAAK,KAAK,UAAU;AACpB,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,OAAe;AACpB,SAAK,OAAO,KAAK,KAAK;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,cAAsB;AAClC,SAAK,cAAc,KAAK,YAAY;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA,EAKA,SACE,SACA,cACA,cACA;AACA,SAAK,QAAQ,KAAK;AAAA,MAChB;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgB,gBAAwB;AACtC,SAAK,gBAAgB,KAAK,cAAc;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,QAAgC;AACpC,UAAM,MAAM,IAAI,cAAc;AAE9B,UAAM,WAAW;AAAA,MACf,KAAK,UAAU,GAAG;AAAA,MAClB,KAAK,aAAa,GAAG;AAAA,MACrB,KAAK,iBAAiB,GAAG;AAAA,IAC3B;AAGA,QAAI,CAAC,KAAK,QAAQ,aAAa,KAAK,gBAAgB,SAAS,GAAG;AAC9D,eAAS,KAAK,KAAK,kBAAkB,GAAG,CAAC;AAAA,IAC3C;AAEA,UAAM,QAAQ,IAAI,QAAQ;AAK1B,QAAI,KAAK,gBAAgB,SAAS,GAAG;AACnC,YAAM,KAAK,kBAAkB,GAAG;AAAA,IAClC;AAEA,WAAO;AAAA,EACT;AAAA,EAEA,MAAc,UAAU,KAAoB;AAC1C,QAAI,KAAK,OAAO,WAAW,GAAG;AAC5B;AAAA,IACF;AACA,UAAM,UAAU,KAAK,OAAO,IAAI,CAAC,UAAU;AACzC,YAAM,CAAC,cAAc,IAAI,IAAI,MAAM,MAAM,GAAG;AAC5C,aAAO,KAAK,UAAU,SAAS,cAAc,MAAM;AAAA,QACjD,MAAM,KAAK,QAAQ;AAAA,MACrB,CAAC;AAAA,IACH,CAAC;AACD,UAAM,OAAO,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO;AAC5C,SAAK,OAAO,QAAQ,CAAC,OAAO,MAAM;AAChC,YAAM,MAAM,KAAK,CAAC;AAClB,UAAI,CAAC,IAAI,QAAQ;AACf,gBAAQ,KAAK,QAAQ,KAAK,kBAAkB;AAC5C;AAAA,MACF;AACA,YAAM,UAAU,cAAc,IAAI,KAAK,CAAC;AACxC,UAAI,KAAK,KAAK,IAAI;AAElB,UAAI,KAAK,QAAQ,WAAW;AAC1B,aAAK,gBAAgB,KAAK;AAAA,MAC5B;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,aAAa,KAAoB;AAC7C,QAAI,KAAK,QAAQ,WAAW,GAAG;AAC7B;AAAA,IACF;AACA,UAAM,OAAO,KAAK,QAAQ;AAE1B,UAAM,cAAc,OAAO,cAAiC;AAC1D,YAAM,WAAW,KAAK,UAAU;AAAA,QAC9B,UAAU;AAAA,QACV,EAAC,KAAI;AAAA,MACP;AACA,YAAM,eAAe,UAAU,gBAAgB,CAAC;AAChD,UAAI,QAAe,KAAK,GAAG,WAAW,QAAQ;AAC9C,UAAI,aAAa,OAAO;AACtB,gBAAQ,MAAM,MAAM,aAAa,KAAK;AAAA,MACxC;AACA,UAAI,aAAa,QAAQ;AACvB,gBAAQ,MAAM,OAAO,aAAa,MAAM;AAAA,MAC1C;AACA,UAAI,aAAa,SAAS;AACxB,gBAAQ,MAAM;AAAA,UACZ,aAAa;AAAA,UACb,aAAa;AAAA,QACf;AAAA,MACF;AACA,UAAI,aAAa,OAAO;AACtB,gBAAQ,aAAa,MAAM,KAAK;AAAA,MAClC;AACA,YAAM,UAAU,MAAM,MAAM,IAAI;AAChC,YAAM,OAAc,CAAC;AACrB,cAAQ,QAAQ,CAAC,WAAW;AAC1B,cAAM,MAAM,cAAc,OAAO,KAAK,CAAC;AACvC,aAAK,KAAK,GAAG;AAAA,MACf,CAAC;AACD,UAAI,QAAQ,UAAU,OAAO,IAAI;AAAA,IACnC;AAEA,UAAM,QAAQ,IAAI,KAAK,QAAQ,IAAI,CAAC,cAAc,YAAY,SAAS,CAAC,CAAC;AAAA,EAC3E;AAAA,EAEA,MAAc,iBAAiB,KAAoB;AACjD,QAAI,KAAK,cAAc,WAAW,GAAG;AACnC;AAAA,IACF;AACA,UAAM,UAAU,KAAK,cAAc,IAAI,CAAC,iBAAiB;AACvD,aAAO,KAAK,UAAU,oBAAoB,cAAc;AAAA,QACtD,MAAM,KAAK,QAAQ;AAAA,MACrB,CAAC;AAAA,IACH,CAAC;AACD,UAAM,OAAO,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO;AAC5C,SAAK,cAAc,QAAQ,CAAC,cAAc,MAAM;AAC9C,YAAM,MAAM,KAAK,CAAC;AAClB,UAAI,CAAC,IAAI,QAAQ;AACf,gBAAQ,KAAK,iBAAiB,YAAY,kBAAkB;AAC5D;AAAA,MACF;AACA,UAAI,YAAY,YAAY,IAAI,IAAI,KAAK;AAAA,IAC3C,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,kBAAkB,KAAoB;AAClD,QAAI,KAAK,gBAAgB,WAAW,GAAG;AACrC;AAAA,IACF;AAEA,UAAM,UAAU,KAAK,gBAAgB,IAAI,CAAC,mBAAmB;AAC3D,aAAO,KAAK,UAAU,kBAAkB,gBAAgB;AAAA,QACtD,MAAM,KAAK,QAAQ;AAAA,MACrB,CAAC;AAAA,IACH,CAAC;AACD,UAAM,OAAO,MAAM,KAAK,GAAG,OAAO,GAAG,OAAO;AAC5C,SAAK,gBAAgB,QAAQ,CAAC,gBAAgB,MAAM;AAClD,YAAM,MAAM,KAAK,CAAC;AAClB,UAAI,CAAC,IAAI,QAAQ;AAEf;AAAA,MACF;AACA,UAAI,aAAa,cAAc,IAAI,IAAI,KAAK;AAAA,IAC9C,CAAC;AAAA,EACH;AACF;AAEO,IAAM,gBAAN,MAAoB;AAAA,EAApB;AACL,gBAA4B,CAAC;AAC7B,mBAAiC,CAAC;AAClC,uBAA8C,CAAC;AAC/C,wBAAgD,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYjD,gBAAgB,QAA+C;AAC7D,UAAM,kBAAkB,KAAK,mBAAmB;AAChD,UAAM,eAAe,sBAAsB,iBAAiB,MAAM;AAClE,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,qBAAsC;AAK5C,UAAM,mBAAmB,OAAO,OAAO,KAAK,YAAY,EAAE,QAAQ;AAIlE,UAAM,kBAAmC,CAAC;AAC1C,eAAW,mBAAmB,kBAAkB;AAC9C,YAAM,UAAU,gBAAgB,WAAW,CAAC;AAC5C,iBAAW,QAAQ,SAAS;AAC1B,cAAM,eAAe,QAAQ,IAAI;AACjC,wBAAgB,IAAI,MAAM,EAAC,QAAQ,aAAa,OAAM;AACtD,mBAAW,UAAU,cAAc;AACjC,cAAI,WAAW,YAAY,aAAa,MAAM,GAAG;AAC/C,4BAAgB,IAAI,EAAE,MAAM,IAAI,aAAa,MAAM;AAAA,UACrD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAKO,SAAS,eAAe,MAAW;AAQxC,SAAO;AAAA,IACL,SAAS,IAAI,KAAK,MAAM,QAAQ,KAAK,MAAM,KAAK,KAAK,QAAQ,KAAK;AAAA,EACpE;AACF;AAMO,SAAS,YAAY,MAAgB;AAE1C,MAAI,eAAe,IAAI,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,SAAc,CAAC;AACrB,aAAW,OAAO,MAAM;AACtB,UAAM,MAAM,KAAK,GAAG;AACpB,QAAI,SAAS,GAAG,GAAG;AACjB,aAAO,GAAG,IAAI,YAAY,GAAG;AAAA,IAC/B,WAAW,MAAM,QAAQ,GAAG,GAAG;AAC7B,UAAI,IAAI,SAAS,KAAK,IAAI,KAAK,CAAC,SAAS,SAAS,IAAI,CAAC,GAAG;AACxD,cAAM,QAAQ,IAAI,IAAI,CAAC,SAAS;AAC9B,cAAI,SAAS,IAAI,GAAG;AAClB,mBAAO,YAAY,IAAI;AAAA,UACzB;AACA,iBAAO;AAAA,QACT,CAAC;AACD,eAAO,GAAG,IAAI,cAAc,KAAK;AAAA,MACnC,OAAO;AACL,eAAO,GAAG,IAAI;AAAA,MAChB;AAAA,IACF,OAAO;AACL,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;AAiBO,SAAS,cAAc,MAAgB;AAC5C,QAAM,SAAc,CAAC;AACrB,aAAW,OAAO,MAAM;AACtB,UAAM,MAAM,KAAK,GAAG;AACpB,QAAI,SAAS,GAAG,GAAG;AACjB,UAAI,IAAI,UAAU;AAChB,eAAO,GAAG,IAAI,IAAI,SAAS;AAAA,MAC7B,WAAW,OAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,QAAQ,IAAI,MAAM,GAAG;AACpE,cAAM,MAAM,IAAI,OAAO,IAAI,CAAC,aAAqB;AAC/C,iBAAO;AAAA,YACL,GAAG,cAAc,IAAI,QAAQ,KAAK,CAAC,CAAC;AAAA,YACpC,WAAW;AAAA,UACb;AAAA,QACF,CAAC;AACD,eAAO,GAAG,IAAI;AAAA,MAChB,OAAO;AACL,eAAO,GAAG,IAAI,cAAc,GAAG;AAAA,MACjC;AAAA,IACF,OAAO;AACL,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACA,SAAO;AACT;AAuBO,SAAS,cAAc,KAAyB;AACrD,MAAI,CAAC,MAAM,QAAQ,GAAG,GAAG;AACvB,WAAO;AAAA,EACT;AACA,QAAM,YAAyB,EAAC,QAAQ,CAAC,EAAC;AAC1C,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,WAAW,CAAC;AACxB,cAAU,GAAG,IAAI;AACjB,cAAU,OAAO,KAAK,GAAG;AAAA,EAC3B;AACA,SAAO;AACT;AAeA,SAAS,SAAS,MAAoB;AACpC,SAAO,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,KAAK,SAAS;AACtE;AAEA,SAAS,WAAW,KAAqB;AACvC,QAAM,SAAS,CAAC;AAChB,QAAM,QACJ;AACF,WAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,UAAM,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,MAAM,MAAM;AACpD,WAAO,KAAK,MAAM,OAAO,IAAI,CAAC;AAAA,EAChC;AACA,SAAO,OAAO,KAAK,EAAE;AACvB;AAaO,SAAS,sBACd,iBACA,QACA;AACA,QAAM,qBAAyC,CAAC;AAEhD,QAAM,kBAAkB,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAM;AAChE,MAAI,CAAC,gBAAgB,SAAS,IAAI,GAAG;AACnC,oBAAgB,KAAK,IAAI;AAAA,EAC3B;AAEA,SAAO,OAAO,eAAe,EAAE,QAAQ,CAAC,WAAW;AACjD,UAAM,SAAS,OAAO;AACtB,QAAI,cAAc;AAClB,eAAW,kBAAkB,iBAAiB;AAC5C,UAAI,OAAO,cAAc,GAAG;AAC1B,sBAAc,OAAO,cAAc;AACnC;AAAA,MACF;AAAA,IACF;AACA,uBAAmB,MAAM,IAAI;AAAA,EAC/B,CAAC;AACD,SAAO;AACT;AAGA,SAAS,aAAa,KAAU;AAC9B,WAAS,OAAOE,MAAkB;AAChC,QAAIA,SAAQ,MAAM;AAChB,aAAO;AAAA,IACT;AACA,QAAI,OAAOA,SAAQ,aAAa;AAC9B,aAAO;AAAA,IACT;AACA,QAAI,OAAOA,SAAQ,UAAU;AAC3B,aAAO,IAAIA,KAAI,WAAW,KAAK,KAAK,CAAC;AAAA,IACvC;AACA,QAAI,OAAOA,SAAQ,UAAU;AAC3B,aAAO,OAAOA,IAAG;AAAA,IACnB;AACA,QAAI,MAAM,QAAQA,IAAG,GAAG;AACtB,aAAO,IAAIA,KAAI,IAAI,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,IACvC;AACA,UAAM,UAAoB,OAAO,QAAQA,IAAG,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM;AAClE,aAAO,GAAG,GAAG,KAAK,OAAO,KAAK,CAAC;AAAA,IACjC,CAAC;AACD,WAAO,IAAI,QAAQ,KAAK,IAAI,CAAC;AAAA,EAC/B;AACA,SAAO,OAAO,GAAG;AACnB;AAKO,SAAS,WAAW,OAAe;AACxC,QAAM,WAAW,MAAM,QAAQ,GAAG;AAClC,MAAI,YAAY,GAAG;AACjB,UAAM,IAAI,MAAM,mBAAmB,KAAK,EAAE;AAAA,EAC5C;AACA,QAAM,aAAa,MAAM,MAAM,GAAG,QAAQ;AAC1C,QAAM,OAAO,MAAM,MAAM,WAAW,CAAC,EAAE,WAAW,KAAK,IAAI;AAC3D,MAAI,CAAC,cAAc,CAAC,MAAM;AACxB,UAAM,IAAI,MAAM,mBAAmB,KAAK,EAAE;AAAA,EAC5C;AACA,SAAO,EAAC,YAAY,KAAI;AAC1B;;;ACliDA,OAAO,UAAU;AAEjB,SAA0B,aAAAC,kBAAgB;AAC1C,OAAO,UAAU;AAMjB,IAAM,uBAAuB,IAAI,KAAK;AAa/B,IAAM,kBAAN,MAAsB;AAAA,EAK3B,YAAY,YAAwB;AAClC,SAAK,aAAa;AAClB,UAAMC,aAAY,aAAa,UAAU;AACzC,UAAM,mBAAmBA,WAAU,UAAU;AAC7C,UAAM,YAAY,iBAAiB,MAAM;AACzC,SAAK,YAAY;AACjB,SAAK,KAAKA,WAAU,aAAa;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,eAAe;AAInB,UAAM,UAAU,MAAM,KAAK,WAAW;AACtC,UAAM,oBACJ,YAAY,IAAI,UAAU,UAAU;AACtC,UAAM,cAAc,MAAM,KAAK,qBAAqB,iBAAiB;AACrE,UAAM,MAAMC,WAAU,IAAI,EAAE,SAAS;AACrC,UAAM,WAAW,YAAY,OAAO,CAAC,QAAQ;AAC3C,YAAM,aAAa,IAAI,IAAI,WAAW,SAAS;AAC/C,aAAO,cAAc,MAAM;AAAA,IAC7B,CAAC;AACD,QAAI,SAAS,SAAS,GAAG;AACvB,WAAK,wBAAwB,QAAQ;AAAA,IACvC;AACA,SAAK,YAAY,GAAG;AAAA,EACtB;AAAA,EAEA,MAAc,wBAAwB,UAA2B;AAC/D,UAAM,QAAQ,KAAK,GAAG,MAAM;AAC5B,aAAS,QAAQ,CAAC,YAAY;AAhFlC;AAiFM,UAAI,CAAC,QAAQ,cAAc,CAAC,QAAQ,QAAQ,GAAC,aAAQ,QAAR,mBAAa,aAAY;AACpE;AAAA,MACF;AACA,YAAM,mBAAmB,QAAQ,IAAI,WAAW,SAAS;AACzD,YAAM,cAAc,YAAY,KAAK,SAAS,gBAAgB,QAAQ,UAAU,WAAW,QAAQ,IAAI,aAAa,gBAAgB;AACpI,cAAQ,IAAI,WAAW;AACvB,YAAM,aAAa,KAAK,GAAG,IAAI,WAAW;AAC1C,YAAM,IAAI,YAAY,OAAO;AAAA,IAC/B,CAAC;AACD,UAAM,MAAM,OAAO;AACnB,YAAQ,IAAI,mBAAmB,SAAS,MAAM,WAAW;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAc,aAA8B;AAC1C,UAAM,gBAAgB,KAAK,GAAG,WAAW,UAAU,EAAE,IAAI,KAAK,SAAS;AACvE,UAAM,aAAa,MAAM,cAAc,IAAI;AAC3C,QAAI,WAAW,QAAQ;AACrB,YAAM,OAAO,WAAW,KAAK,KAAK,CAAC;AACnC,YAAM,KAAK,KAAK;AAChB,UAAI,IAAI;AACN,eAAO,GAAG,SAAS;AAAA,MACrB;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,YAAY,QAAgB;AACxC,UAAM,KAAKA,WAAU,WAAW,MAAM;AACtC,UAAM,gBAAgB,KAAK,GAAG,WAAW,UAAU,EAAE,IAAI,KAAK,SAAS;AACvE,UAAM,cAAc,IAAI,EAAC,iBAAiB,GAAE,GAAG,EAAC,OAAO,KAAI,CAAC;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,qBAAqB,QAA0C;AAC3E,UAAM,KAAKA,WAAU,WAAW,MAAM;AACtC,UAAM,UAA2B,CAAC;AAClC,UAAM,gBAAgB,MAAM,KAAK,gBAAgB;AAIjD,eAAW,gBAAgB,eAAe;AACxC,YAAM,iBAAiB,YAAY,KAAK,SAAS,gBAAgB,YAAY;AAC7E,YAAM,QAAe,KAAK,GACvB,WAAW,cAAc,EACzB,MAAM,kBAAkB,MAAM,EAAE;AACnC,YAAM,gBAAgB,MAAM,MAAM,IAAI;AACtC,oBAAc,QAAQ,CAAC,QAAQ;AAC7B,gBAAQ,KAAK,IAAI,KAAK,CAAkB;AAAA,MAC1C,CAAC;AAAA,IACH;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,kBAAqC;AACjD,UAAM,gBAA0B,CAAC;AACjC,UAAM,sBAAsB,MAAM,KAAK,eAAe;AAAA,MACpD,KAAK,KAAK,KAAK,KAAK,WAAW,SAAS,aAAa;AAAA,IACvD,CAAC;AACD,wBAAoB,QAAQ,CAAC,aAAa;AACxC,oBAAc,KAAK,SAAS,MAAM,GAAG,GAAG,CAAC;AAAA,IAC3C,CAAC;AACD,WAAO;AAAA,EACT;AACF;;;ACxJA,eAAsB,YAAY,YAAwB;AACxD,QAAM,QAAQ,IAAI;AAAA,IAChB,WAAW,wBAAwB,yBAAyB,UAAU;AAAA,IACtE,WAAW,gBAAgB,iBAAiB,UAAU;AAAA,EACxD,CAAC;AACH;AAEA,eAAe,WACb,MACA,OACG,MACH;AACA,MAAI;AACF,UAAM,GAAG,GAAG,IAAI;AAAA,EAClB,SAAS,KAAK;AACZ,YAAQ,IAAI,gBAAgB,IAAI,EAAE;AAClC,YAAQ,MAAM,OAAO,IAAI,SAAS,GAAG,CAAC;AACtC,UAAM;AAAA,EACR;AACF;AAEA,eAAe,wBAAwB,YAAwB;AAC7D,QAAM,YAAY,IAAI,cAAc,UAAU;AAC9C,QAAM,UAAU,qBAAqB;AACrC,QAAM,UAAU,yBAAyB;AAC3C;AAEA,eAAe,gBAAgB,YAAwB;AACrD,QAAM,UAAU,IAAI,gBAAgB,UAAU;AAC9C,QAAM,QAAQ,aAAa;AAC7B;;;AClCA,SAAQ,SAAS,gBAAe;AAChC,SAAQ,aAAa,oBAAmB;AAEjC,SAAS,WAAW,KAGhB;AACT,QAAM,UAAU,IAAI,WAAW,CAAC;AAChC,QAAM,OAAO,IAAI,QAAQ,CAAC;AAC1B,SAAO,aAAa,MAAM;AAAA,IACxB,QAAQ;AAAA,IACR,SAAS;AAAA,EACX,CAAC;AACH;AAEO,SAAS,WAAW,WAAmB;AAC5C,QAAM,OAAO,SAAS,WAAW;AAAA,IAC/B,SAAS;AAAA,IACT,kBAAkB;AAAA,EACpB,CAAC;AACD,SAAO;AACT;;;ALXO,SAAS,IAAI,QAAgB;AAIlC,SAAO,IAAI,qBAAqB,OAAO,KAAc,QAAkB;AACrE,QAAI;AACF,YAAM,YAAY,IAAI,UAAW;AACjC,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,KAAI,CAAC;AAAA,IACtC,SAAS,KAAK;AACZ,cAAQ,MAAM,GAAG;AACjB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,MAAK,CAAC;AAAA,IACvC;AAAA,EACF,CAAC;AAkBD,SAAO,IAAI,yBAAyB,CAAC,KAAc,QAAkB;AACnE,QACE,IAAI,WAAW,UACf,CAAC,OAAO,IAAI,IAAI,cAAc,CAAC,EAAE,WAAW,kBAAkB,GAC9D;AACA,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,cAAa,CAAC;AAC3D;AAAA,IACF;AAEA,QAAI;AACF,YAAM,OAAO,IAAI,QAAQ,CAAC;AAC1B,YAAM,UAAU,KAAK,WAAW,CAAC;AACjC,YAAM,OAAO,KAAK,QAAQ,CAAC;AAC3B,YAAM,MAAM,WAAW,EAAC,SAAS,KAAI,CAAC;AACtC,UAAI,UAAU,gBAAgB,UAAU;AACxC,UAAI,UAAU,uBAAuB,iCAAiC;AACtE,UAAI,OAAO,GAAG,EAAE,IAAI,GAAG;AAAA,IACzB,SAAS,KAAK;AACZ,cAAQ,MAAM,IAAI,SAAS,GAAG;AAC9B,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,UAAS,CAAC;AAAA,IACzD;AAAA,EACF,CAAC;AAkBD,SAAO;AAAA,IACL;AAAA,IACA,oBAAoB;AAAA,IACpB,CAAC,KAAc,QAAkB;AAC/B,UAAI,IAAI,WAAW,UAAU,CAAC,IAAI,SAAS,CAAC,IAAI,MAAM,MAAM;AAC1D,YAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,cAAa,CAAC;AAC3D;AAAA,MACF;AAEA,UAAI;AACF,cAAM,OAAO,IAAI,MAAM;AACvB,cAAM,YAAY,KAAK,OAAO,SAAS,MAAM;AAC7C,cAAM,OAAO,WAAW,SAAS;AACjC,YAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,MAAM,MAAM,KAAI,CAAC;AAAA,MAClD,SAAS,KAAK;AACZ,gBAAQ,MAAM,IAAI,SAAS,GAAG;AAC9B,YAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,UAAS,CAAC;AAAA,MACzD;AAAA,IACF;AAAA,EACF;AAKA,SAAO,IAAI,sBAAsB,OAAO,KAAc,QAAkB;AAvG1E;AAwGI,QACE,IAAI,WAAW,UACf,CAAC,OAAO,IAAI,IAAI,cAAc,CAAC,EAAE,WAAW,kBAAkB,GAC9D;AACA,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,cAAa,CAAC;AAC3D;AAAA,IACF;AAEA,QAAI,GAAC,SAAI,SAAJ,mBAAU,QAAO;AACpB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,eAAc,CAAC;AAAA,IAC9D;AAEA,UAAM,UAAU,IAAI,QAAQ,CAAC;AAC7B,UAAM,eAAe,QAAQ;AAC7B,QAAI,CAAC,cAAc;AACjB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,aAAY,CAAC;AAC1D;AAAA,IACF;AACA,UAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,QAAI;AACF,YAAM,UAAU,eAAe,cAAc,EAAC,UAAU,IAAI,KAAK,MAAK,CAAC;AACvE,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,MAAM,IAAI,aAAY,CAAC;AAAA,IACxD,SAAS,KAAK;AACZ,cAAQ,MAAM,IAAI,SAAS,GAAG;AAC9B,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,UAAS,CAAC;AAAA,IACzD;AAAA,EACF,CAAC;AAKD,SAAO,IAAI,wBAAwB,OAAO,KAAc,QAAkB;AAvI5E;AAwII,QACE,IAAI,WAAW,UACf,CAAC,OAAO,IAAI,IAAI,cAAc,CAAC,EAAE,WAAW,kBAAkB,GAC9D;AACA,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,cAAa,CAAC;AAC3D;AAAA,IACF;AAEA,QAAI,GAAC,SAAI,SAAJ,mBAAU,QAAO;AACpB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,eAAc,CAAC;AAAA,IAC9D;AAEA,UAAM,UAAU,IAAI,QAAQ,CAAC;AAC7B,UAAM,SAAS,QAAQ;AACvB,QAAI,CAAC,QAAQ;AACX,UAAI,OAAO,GAAG,EAAE,KAAK;AAAA,QACnB,SAAS;AAAA,QACT,OAAO;AAAA,QACP,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AACA,UAAM,WAAW,QAAQ,YAAY,CAAC;AAEtC,UAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,QAAI;AACF,YAAM,UAAU,UAAU,QAAQ;AAAA,QAChC,KAAI,SAAI,SAAJ,mBAAU;AAAA,QACd;AAAA,MACF,CAAC;AACD,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,KAAI,CAAC;AAAA,IACtC,SAAS,KAAK;AACZ,cAAQ,MAAM,IAAI,SAAS,GAAG;AAC9B,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,UAAS,CAAC;AAAA,IACzD;AAAA,EACF,CAAC;AAKD,SAAO,IAAI,oBAAoB,OAAO,KAAc,QAAkB;AA/KxE;AAgLI,QACE,IAAI,WAAW,UACf,CAAC,OAAO,IAAI,IAAI,cAAc,CAAC,EAAE,WAAW,kBAAkB,GAC9D;AACA,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,cAAa,CAAC;AAC3D;AAAA,IACF;AACA,QAAI,GAAC,SAAI,SAAJ,mBAAU,QAAO;AACpB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,eAAc,CAAC;AAC5D;AAAA,IACF;AACA,UAAM,UAAU,IAAI,QAAQ,CAAC;AAC7B,QAAI,CAAC,QAAQ,QAAQ;AACnB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,iBAAgB,CAAC;AAC9D;AAAA,IACF;AACA,UAAM,SAAS,QAAQ;AAEvB,QAAI;AACF,YAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,YAAM,aAAa,IAAI,WAAW,WAAW,IAAI,KAAK,KAAK;AAC3D,UAAI;AACJ,UAAI,QAAQ,QAAQ;AAClB,eAAO,MAAM,WAAW,QAAQ,QAAQ,MAAM;AAAA,MAChD,OAAO;AACL,eAAO,MAAM,WAAW,WAAW;AAAA,MACrC;AACA,YAAM,eAAe,MAAM,KAAK,WAAW,MAAM;AACjD,UACG,OAAO,GAAG,EACV,KAAK,EAAC,SAAS,MAAM,QAAQ,KAAK,IAAI,UAAU,aAAY,CAAC;AAAA,IAClE,SAAS,KAAK;AACZ,cAAQ,MAAM,IAAI,SAAS,GAAG;AAC9B,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,UAAS,CAAC;AAAA,IACzD;AAAA,EACF,CAAC;AAED,SAAO,IAAI,0BAA0B,OAAO,KAAc,QAAkB;AArN9E;AAsNI,QACE,IAAI,WAAW,UACf,CAAC,OAAO,IAAI,IAAI,cAAc,CAAC,EAAE,WAAW,kBAAkB,GAC9D;AACA,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,cAAa,CAAC;AAC3D;AAAA,IACF;AACA,QAAI,GAAC,SAAI,SAAJ,mBAAU,QAAO;AACpB,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,eAAc,CAAC;AAC5D;AAAA,IACF;AACA,UAAM,UAAU,IAAI,QAAQ,CAAC;AAC7B,UAAM,QAAQ,QAAQ;AAEtB,QAAI;AACF,YAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,YAAM,aAAa,IAAI,WAAW,WAAW,IAAI,KAAK,KAAK;AAC3D,YAAM,QAAQ,MAAM,WAAW,UAAU,EAAC,MAAK,CAAC;AAChD,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,MAAM,MAAK,CAAC;AAAA,IAC7C,SAAS,KAAK;AACZ,cAAQ,MAAM,IAAI,SAAS,GAAG;AAC9B,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,UAAS,CAAC;AAAA,IACzD;AAAA,EACF,CAAC;AACH;;;AM7OA,SAAQ,aAAAC,kBAAgB;AAYxB,eAAsB,uBAAuB,YAAwB;AACnE,QAAM,YAAY,IAAI,cAAc,UAAU;AAC9C,QAAM,YAAY,UAAU;AAC5B,QAAM,KAAK,UAAU;AACrB,QAAM,sBAAsB,GAAG,IAAI,YAAY,SAAS,EAAE;AAC1D,QAAM,mBAAmB,MAAM,oBAAoB,IAAI;AACvD,QAAM,gBAAgB,iBAAiB,KAAK,KAAK,CAAC;AAElD,QAAM,wBAAwB,cAAc,iBAAiB,CAAC;AAC9D,MAAI,kBAAkB;AAEtB,QAAM,sBAAsB,sBAAsB,gBAAgB;AAClE,MAAI,sBAAsB,GAAG;AAC3B,UAAM,wBAAwB,YAAY,SAAS;AACnD,0BAAsB,eAAe;AACrC,sBAAkB;AAAA,EACpB;AAEA,MAAI,iBAAiB;AACnB,UAAM,oBAAoB,OAAO,EAAC,eAAe,sBAAqB,CAAC;AACvE,YAAQ,IAAI,qCAAqC;AAAA,EACnD;AACF;AAKA,eAAe,wBACb,YACA,WACA;AA3CF;AA4CE,OAAI,gBAAW,gBAAX,mBAAwB,qCAAqC;AAC/D;AAAA,EACF;AAEA,QAAM,YAAY,UAAU;AAC5B,QAAM,KAAK,UAAU;AACrB,QAAM,SAAS,YAAY,SAAS;AACpC,QAAM,QAAQ,GAAG,WAAW,MAAM;AAClC,QAAM,gBAAgB,MAAM,MAAM,IAAI;AACtC,MAAI,cAAc,SAAS,GAAG;AAC5B;AAAA,EACF;AAEA,UAAQ,IAAI,mDAAmD;AAE/D,QAAM,mBAAoD,CAAC;AAC3D,gBAAc,QAAQ,CAAC,QAAQ;AAC7B,UAAM,OAAO,IAAI;AACjB,UAAM,cAAc,IAAI,KAAK;AAC7B,UAAM,OAAQ,YAAY,QAAQ,CAAC;AACnC,WAAO,YAAY;AACnB,eAAW,OAAO,MAAM;AACtB,UAAI,IAAI,SAAS,GAAG,GAAG;AACrB,cAAM,iBAAiB,IAAI,WAAW,KAAK,IAAI;AAC/C,yBAAiB,cAAc,MAAM;AAAA,UACnC,IAAI;AAAA,UACJ,KAAK;AAAA,YACH,YAAYC,WAAU,IAAI;AAAA,YAC1B,YAAY;AAAA,YACZ,aAAaA,WAAU,IAAI;AAAA,YAC3B,aAAa;AAAA,YACb;AAAA,UACF;AAAA,UACA,SAAS,CAAC;AAAA,QACZ;AACA,yBAAiB,cAAc,EAAE,QAAQ,IAAI,IAAI;AAAA,MACnD;AAAA,IACF;AAAA,EACF,CAAC;AAED,MAAI,OAAO,KAAK,gBAAgB,EAAE,WAAW,GAAG;AAC9C,YAAQ,IAAI,oCAAoC;AAChD;AAAA,EACF;AAIA,aAAW,SAAS,kBAAkB;AACpC,UAAM,CAAC,YAAY,IAAI,IAAI,MAAM,MAAM,GAAG;AAC1C,QAAI,cAAc,MAAM;AACtB,YAAM,MAAW,MAAM,UAAU,OAAO,YAAY,MAAM;AAAA,QACxD,MAAM;AAAA,MACR,CAAC;AACD,YAAM,eAAc,gCAAK,QAAL,mBAAU;AAC9B,UAAI,aAAa;AACf,yBAAiB,KAAK,EAAE,IAAI,cAAc;AAAA,MAC5C;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ,GAAG,MAAM;AACvB,SAAO,QAAQ,gBAAgB,EAAE,QAAQ,CAAC,CAAC,gBAAgB,IAAI,MAAM;AACnE,UAAM,WAAW,GAAG;AAAA,MAClB,YAAY,SAAS,2CAA2C,cAAc;AAAA,IAChF;AACA,UAAM,eAAe,GAAG;AAAA,MACtB,YAAY,SAAS,+CAA+C,cAAc;AAAA,IACpF;AACA,UAAM,IAAI,UAAU,MAAM,EAAC,OAAO,KAAI,CAAC;AACvC,UAAM,IAAI,cAAc,MAAM,EAAC,OAAO,KAAI,CAAC;AAC3C,UAAM,MAAM,OAAO,KAAK,KAAK,OAAO,EAAE;AACtC,YAAQ,IAAI,qBAAqB,GAAG,iBAAiB,cAAc,KAAK;AAAA,EAC1E,CAAC;AACD,QAAM,MAAM,OAAO;AAEnB,UAAQ,IAAI,8CAA8C;AAC5D;;;AP7FA,IAAMC,aAAYC,MAAK,QAAQC,eAAc,YAAY,GAAG,CAAC;AAK7D,IAAM,sBAAsB;AAmJ5B,SAAS,UAAU,gBAAgC;AACjD,QAAM,KAAK,KAAK,OAAM,oBAAI,KAAK,GAAE,QAAQ,IAAI,GAAI;AACjD,SAAO,MAAM,eAAe;AAC9B;AAEA,SAAS,eAAe,cAA2B;AACjD,QAAM,UAAU;AAChB,MAAI;AACF,WAAO,OAAO,OAAO;AAAA,EACvB,SAAS,KAAK;AACZ,QAAI,OAAO,IAAI,SAAS,cAAc;AACpC,aAAO;AAAA,QACL;AAAA,UACE,WAAW;AAAA,UACX,YAAY,mBAAmB;AAAA,QACjC;AAAA,QACA;AAAA,MACF;AAAA,IACF;AACA,UAAM;AAAA,EACR;AACF;AAEO,SAAS,UAAU,SAAsC;AAC9D,QAAM,WAAW,QAAQ,YAAY;AAErC,MAAI,CAAC,QAAQ,gBAAgB;AAC3B,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,iBAAiB,QAAQ,kBAAkB,CAAC;AAClD,QAAM,MAAM,eAAe,eAAe,SAAS;AACnD,QAAM,OAAO,QAAQ,GAAG;AAMxB,WAAS,cAAc,KAAuB;AAC5C,UAAM,UAAU,OAAO,IAAI,WAAW,EAAE,MAAM,GAAG,EAAE,CAAC,EAAE,YAAY;AAGlE,QAAI,YAAY,qBAAqB;AACnC,aAAO;AAAA,IACT;AAEA,QACE,YAAY,4BACZ,YAAY,yBACZ;AACA,aAAO;AAAA,IACT;AAEA,QAAI,QAAQ,WAAW,MAAM,GAAG;AAC9B,aAAO;AAAA,IACT;AAGA,QAAI,OAAO,IAAI,MAAM,OAAO,MAAM,QAAQ;AACxC,aAAO;AAAA,IACT;AACA,QAAI,QAAQ,mBAAmB,QAAQ,gBAAgB,GAAG,GAAG;AAC3D,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT;AAQA,iBAAe,gBACb,KACiD;AAhQrD;AAiQI,UAAM,WAAU,SAAI,SAAJ,mBAAU;AAC1B,QAAI,CAAC,SAAS;AACZ,cAAQ,IAAI,2BAA2B;AACvC,aAAO,EAAC,YAAY,OAAO,QAAQ,WAAU;AAAA,IAC/C;AAEA,QAAI;AAOJ,QAAI;AACF,UAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,cAAM,MAAmB,oBAAO,OAAO;AACvC,YAAI,CAAC,IAAI,SAAS,CAAC,IAAI,gBAAgB;AACrC,kBAAQ,IAAI,gCAAgC;AAC5C,iBAAO,EAAC,YAAY,OAAO,QAAQ,eAAc;AAAA,QACnD;AACA,eAAO,EAAC,OAAO,IAAI,MAAK;AAAA,MAC1B,OAAO;AACL,cAAM,MAAM,MAAM,KAAK,cAAc,SAAS,IAAI;AAClD,YAAI,UAAU,GAAG,GAAG;AAClB,kBAAQ,IAAI,mCAAmC;AAC/C,iBAAO,EAAC,YAAY,OAAO,QAAQ,eAAc;AAAA,QACnD;AACA,YAAI,CAAC,IAAI,SAAS,CAAC,IAAI,gBAAgB;AACrC,kBAAQ,IAAI,gCAAgC;AAC5C,iBAAO,EAAC,YAAY,OAAO,QAAQ,eAAc;AAAA,QACnD;AACA,eAAO,EAAC,OAAO,IAAI,MAAK;AAAA,MAC1B;AAGA,UAAI,QAAQ,kBAAkB;AAC5B,cAAM,aAAa,MAAM,QAAQ,iBAAiB,KAAK;AAAA,UACrD,OAAO,KAAK;AAAA,QACd,CAAC;AACD,YAAI,CAAC,YAAY;AACf,kBAAQ,IAAI,sCAAsC;AAClD,iBAAO,EAAC,YAAY,OAAO,QAAQ,iBAAgB;AAAA,QACrD;AAAA,MACF;AAGA,YAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,YAAM,gBAAgB,MAAM,UAAU,gBAAgB,KAAK,KAAK;AAChE,UAAI,CAAC,eAAe;AAClB,gBAAQ,IAAI,qDAAqD;AACjE,eAAO,EAAC,YAAY,OAAO,QAAQ,iBAAgB;AAAA,MACrD;AAAA,IACF,SAAS,KAAK;AACZ,cAAQ,MAAM,4BAA4B;AAC1C,cAAQ,MAAM,GAAG;AACjB,aAAO,EAAC,YAAY,OAAO,QAAQ,gBAAe;AAAA,IACpD;AAEA,WAAO,EAAC,YAAY,KAAI;AAAA,EAC1B;AAOA,iBAAe,eAAe,KAAuC;AACnE,UAAM,gBAAgB,IAAI,QAAQ,QAAQ,mBAAmB;AAC7D,QAAI,CAAC,eAAe;AAClB,UAAI,aAAa,SAAS;AACxB,gBAAQ,IAAI,yBAAyB;AAAA,MACvC;AACA,aAAO;AAAA,IACT;AAIA,QAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,YAAM,MAAmB,oBAAO,aAAa;AAC7C,UAAI,EAAC,2BAAK,UAAS,EAAC,2BAAK,iBAAgB;AACvC,eAAO;AAAA,MACT;AAEA,UAAI,QAAQ,kBAAkB;AAC5B,cAAM,aAAa,MAAM,QAAQ,iBAAiB,KAAK;AAAA,UACrD,OAAO,IAAI;AAAA,QACb,CAAC;AACD,YAAI,CAAC,YAAY;AACf,kBAAQ,IAAI,gCAAgC;AAC5C,iBAAO;AAAA,QACT;AAAA,MACF;AAEA,YAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,YAAM,gBAAgB,MAAM,UAAU,gBAAgB,IAAI,KAAK;AAC/D,UAAI,CAAC,eAAe;AAClB,gBAAQ,IAAI,uDAAuD;AACnE,eAAO;AAAA,MACT;AACA,aAAO,EAAC,OAAO,IAAI,MAAK;AAAA,IAC1B;AAEA,QAAI;AAEF,YAAM,MAAM,MAAM,KAAK,oBAAoB,eAAe,IAAI;AAC9D,UAAI,UAAU,GAAG,GAAG;AAClB,gBAAQ,IAAI,kCAAkC;AAC9C,eAAO;AAAA,MACT;AAEA,UAAI,CAAC,IAAI,SAAS,CAAC,IAAI,gBAAgB;AACrC,gBAAQ,IAAI,oCAAoC;AAChD,eAAO;AAAA,MACT;AAEA,UAAI,QAAQ,kBAAkB;AAC5B,cAAM,aAAa,MAAM,QAAQ,iBAAiB,KAAK;AAAA,UACrD,OAAO,IAAI;AAAA,QACb,CAAC;AACD,YAAI,CAAC,YAAY;AACf,kBAAQ,IAAI,gCAAgC;AAC5C,iBAAO;AAAA,QACT;AAAA,MACF;AAEA,YAAM,YAAY,IAAI,cAAc,IAAI,UAAW;AACnD,YAAM,gBAAgB,MAAM,UAAU,gBAAgB,IAAI,KAAK;AAC/D,UAAI,CAAC,eAAe;AAClB,gBAAQ,IAAI,uDAAuD;AACnE,eAAO;AAAA,MACT;AAEA,aAAO,EAAC,OAAO,IAAI,MAAM;AAAA,IAC3B,SAAS,KAAK;AACZ,cAAQ,MAAM,4BAA4B;AAC1C,cAAQ,MAAM,GAAG;AACjB,aAAO;AAAA,IACT;AAAA,EACF;AAEA,WAAS,gBAAgB,KAAc,KAAe;AACpD,QAAI,OAAO,IAAI,WAAW,EAAE,YAAY,EAAE,WAAW,UAAU,GAAG;AAChE,UAAI,OAAO,GAAG,EAAE,KAAK,EAAC,SAAS,OAAO,OAAO,iBAAgB,CAAC;AAC9D;AAAA,IACF;AACA,YAAQ,IAAI,2BAA2B;AACvC,UAAM,SAAS,IAAI,gBAAgB;AAAA,MACjC,UAAU,IAAI;AAAA,IAChB,CAAC;AACD,QAAI,SAAS,cAAc,OAAO,SAAS,CAAC,EAAE;AAAA,EAChD;AAEA,QAAM,SAAoB;AAAA,IACxB,MAAM;AAAA;AAAA;AAAA;AAAA,IAKN,WAAW,MAAM;AACf,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,gBAAgB,MAAM;AACpB,aAAO;AAAA,IACT;AAAA;AAAA;AAAA;AAAA,IAKA,cAAc,MAAM;AAClB,YAAM,aAAa,eAAe,cAAc;AAChD,aAAO,aAAa,KAAK,UAAU;AAAA,IACrC;AAAA;AAAA;AAAA;AAAA,IAKA,UAAU,OAAO;AAAA,MACf,KAAKD,MAAK,QAAQD,YAAW,UAAU;AAAA,IACzC;AAAA,IAEA,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,MAKL,SAAS,OAAO,EAAC,SAAS,WAAU,MAAM;AACxC,YAAI,YAAY,SAAS,YAAY,SAAS;AAC5C,gBAAM,uBAAuB,UAAU;AAAA,QACzC;AAAA,MACF;AAAA,IACF;AAAA;AAAA;AAAA;AAAA,IAKA,iBAAiB,OACf,QACA,kBACG;AACH,aAAO,IAAI,WAAW,KAAK,CAAC;AAE5B,qBAAe,YAAY,KAAkC;AAC3D,YAAI,cAAc,SAAS,OAAO;AAChC,gBAAM,cAAcC,MAAK,QAAQD,YAAW,UAAU;AACtD,gBAAMG,OAAO,MAAM,IAAI,WAAY;AAAA,YACjC;AAAA,UACF;AACA,iBAAOA;AAAA,QACT;AAEA,cAAM,gBAAgBF,MAAK;AAAA,UACzB,IAAI,WAAY;AAAA,UAChB;AAAA,QACF;AACA,YAAI,CAAE,MAAM,WAAW,aAAa,GAAI;AACtC,gBAAM,IAAI;AAAA,YACR;AAAA,UACF;AAAA,QACF;AACA,cAAME,OAAO,MAAM,OAAO;AAC1B,eAAOA;AAAA,MACT;AAGA,aAAO,IAAI,cAAc,OAAO,KAAc,QAAkB;AAC9D,YACE,IAAI,WAAW,SACf,IAAI,QAAQ,cAAc,MAAM,oBAChC;AACA,cAAI;AACF,kBAAM,EAAC,YAAY,OAAM,IAAI,MAAM,gBAAgB,GAAG;AACtD,gBAAI,CAAC,YAAY;AACf,kBACG,OAAO,GAAG,EACV,KAAK,EAAC,SAAS,OAAO,OAAO,kBAAkB,OAAM,CAAC;AACzD;AAAA,YACF;AAGA,kBAAM,YAAY,KAAK,KAAK,KAAK,IAAI;AACrC,kBAAM,UAAU,IAAI,KAAK;AAEzB,gBAAI;AACJ,gBAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,8BAAgB;AAAA,YAClB,OAAO;AACL,8BAAgB,MAAM,KAAK,oBAAoB,SAAS;AAAA,gBACtD;AAAA,cACF,CAAC;AAAA,YACH;AACA,gBAAI,QAAQ,QAAQ,qBAAqB,aAAa;AACtD,gBAAI,YAAY;AAChB,gBAAI,KAAK,EAAC,SAAS,KAAI,CAAC;AAAA,UAC1B,SAAS,KAAK;AACZ,oBAAQ,MAAM,GAAG;AACjB,gBAAI,IAAI,OAAO;AACb,sBAAQ,MAAM,IAAI,KAAK;AAAA,YACzB;AACA,gBACG,OAAO,GAAG,EACV,KAAK,EAAC,SAAS,OAAO,OAAO,uBAAsB,CAAC;AAAA,UACzD;AACA;AAAA,QACF;AAEA,YAAI;AACF,gBAAMA,OAAM,MAAM,YAAY,GAAG;AACjC,UAAAA,KAAI,aAAa,KAAK,KAAK;AAAA,YACzB,YAAY,IAAI;AAAA,YAChB,WAAW;AAAA,UACb,CAAC;AAAA,QACH,SAAS,KAAK;AACZ,kBAAQ,MAAM,GAAG;AACjB,cAAI,IAAI,OAAO;AACb,oBAAQ,MAAM,IAAI,KAAK;AAAA,UACzB;AACA,cAAI,OAAO,GAAG,EAAE,KAAK,sBAAsB;AAAA,QAC7C;AAAA,MACF,CAAC;AAGD,aAAO,IAAI,eAAe,OAAO,KAAc,QAAkB;AAC/D,YAAI,QAAQ,WAAW,mBAAmB;AAC1C,YAAI,YAAY;AAChB,YAAI,SAAS,YAAY;AAAA,MAC3B,CAAC;AAID,aAAO,IAAI,OAAO,KAAc,KAAe,SAAuB;AACpE,cAAM,OAAO,MAAM,eAAe,GAAG;AACrC,YAAI,MAAM;AACR,cAAI,OAAO;AAAA,QACb;AAIA,YAAI,CAAC,QAAQ,cAAc,GAAG,GAAG;AAC/B,0BAAgB,KAAK,GAAG;AACxB;AAAA,QACF;AAEA,aAAK;AAAA,MACP,CAAC;AAED,YAAM,YAAYF,MAAK,QAAQD,YAAW,IAAI;AAC9C,aAAO,IAAI,eAAe,KAAK,WAAW,EAAC,KAAK,MAAK,CAAC,CAAC;AAGvD,UAAI,MAAM;AAGV,aAAO,IAAI,QAAQ,OAAO,KAAc,QAAkB;AACxD,YAAI;AAIF,cAAI,CAAC,IAAI,MAAM;AACb,4BAAgB,KAAK,GAAG;AACxB;AAAA,UACF;AACA,gBAAMG,OAAM,MAAM,YAAY,GAAG;AACjC,gBAAMA,KAAI,UAAU,KAAK,KAAK;AAAA,YAC5B,YAAY,IAAI;AAAA,YAChB,WAAW;AAAA,UACb,CAAC;AAAA,QACH,SAAS,KAAK;AAEZ,kBAAQ,MAAM,GAAG;AACjB,cAAI,OAAO,GAAG,EAAE,KAAK,sBAAsB;AAAA,QAC7C;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAEA,MAAI,QAAQ,UAAU,OAAO;AAC3B,WAAO,eAAe,CACpB,WACA,aACG;AACH,UAAI,SAAS,SAAS,YAAY,GAAG;AAGnC,sFAAmC,KAAK,CAAC,wBAAwB;AAC/D,gBAAMC,iBAAgB,oBAAoB;AAC1C,UAAAA,eAAc;AAAA,QAChB,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,WAAW,UAAoC;AACtD,SAAOC,IACJ,OAAO,QAAQ,EACf,KAAK,MAAM,IAAI,EACf,MAAM,MAAM,KAAK;AACtB;AAEO,SAAS,aAAa,YAAmC;AAC9D,QAAM,UAAoB,WAAW,WAAW,CAAC;AACjD,QAAM,SAAS,QAAQ,KAAK,CAACC,YAAWA,QAAO,SAAS,UAAU;AAClE,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACA,SAAO;AACT;",
  "names": ["path", "fs", "path", "fileURLToPath", "crypto", "Timestamp", "Timestamp", "crypto", "obj", "Timestamp", "cmsPlugin", "Timestamp", "Timestamp", "Timestamp", "__dirname", "path", "fileURLToPath", "app", "generateTypes", "fs", "plugin"]
}
