@highstate/cli 0.9.16 → 0.9.18

package/src/shared/schema-transformer.spec.ts

@@ -206,4 +206,284 @@ const spec = {
     )
     expect(result).toContain("It also has multiple lines.`")
   })
+
+  it("should add .meta() to z.object fields with JSDoc comments", async () => {
+    const input = `
+const userSchema = z.object({
+  /**
+   * The user's unique identifier.
+   */
+  id: z.string(),
+  /**
+   * The user's email address.
+   */
+  email: z.string().email(),
+  name: z.string(), // no comment, should not be transformed
+})`
+
+    const result = await applySchemaTransformations(input)
+
+    // Should add import at the top
+    expect(result).toContain(
+      'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"',
+    )
+
+    // Should add .meta() with both title and description
+    expect(result).toContain(
+      'id: z.string().meta({ title: __camelCaseToHumanReadable("id"), description: `The user\'s unique identifier.` })',
+    )
+    expect(result).toContain(
+      'email: z.string().email().meta({ title: __camelCaseToHumanReadable("email"), description: `The user\'s email address.` })',
+    )
+    expect(result).toContain("name: z.string(), // no comment") // unchanged
+  })
+
+  it("should not add .meta() if already present in z.object fields", async () => {
+    const input = `
+const userSchema = z.object({
+  /**
+   * The user's identifier.
+   */
+  id: z.string().meta({ displayName: "ID" }),
+})`
+
+    const result = await applySchemaTransformations(input)
+
+    // Should not modify the field that already has .meta()
+    expect(result).toContain('id: z.string().meta({ displayName: "ID" })')
+    expect(result).not.toContain("description:")
+  })
+
+  it("should handle nested z.object patterns", async () => {
+    const input = `
+const schema = z.object({
+  user: z.object({
+    /**
+     * The user's name.
+     */
+    name: z.string(),
+    profile: z.object({
+      /**
+       * The user's age.
+       */
+      age: z.number(),
+    }),
+  }),
+})`
+
+    const result = await applySchemaTransformations(input)
+
+    expect(result).toContain(
+      'name: z.string().meta({ title: __camelCaseToHumanReadable("name"), description: `The user\'s name.` })',
+    )
+    expect(result).toContain(
+      'age: z.number().meta({ title: __camelCaseToHumanReadable("age"), description: `The user\'s age.` })',
+    )
+  })
+
+  it("should handle multiple JSDoc-commented fields in the same z.object without conflicts", async () => {
+    const input = `
+const networkSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("dhcp"),
+  }),
+  z.object({
+    type: z.literal("static"),
+
+    /**
+     * The IPv4 address to assign to the virtual machine.
+     */
+    address: z.string().optional(),
+
+    /**
+     * The CIDR prefix for the IPv4 address.
+     *
+     * By default, this is set to 24.
+     */
+    prefix: z.number().default(24),
+
+    /**
+     * The IPv4 gateway for the virtual machine.
+     *
+     * If not specified, will be set to the first address in the subnet.
+     */
+    gateway: z.string().optional(),
+  }),
+]).default({ type: "dhcp" })`
+
+    const result = await applySchemaTransformations(input)
+
+    expect(result).toContain(
+      'address: z.string().optional().meta({ title: __camelCaseToHumanReadable("address"), description: `The IPv4 address to assign to the virtual machine.` })',
+    )
+    expect(result).toContain(
+      'prefix: z.number().default(24).meta({ title: __camelCaseToHumanReadable("prefix"), description: `The CIDR prefix for the IPv4 address.',
+    )
+    expect(result).toContain("By default, this is set to 24.` })")
+    expect(result).toContain(
+      'gateway: z.string().optional().meta({ title: __camelCaseToHumanReadable("gateway"), description: `The IPv4 gateway for the virtual machine.',
+    )
+    expect(result).toContain(
+      "If not specified, will be set to the first address in the subnet.` })",
+    )
+    expect(result).toContain('type: z.literal("static"),') // unchanged, no comment
+  })
+
+  it("should handle z.object fields inside z.discriminatedUnion", async () => {
+    const input = `
+const schema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("dhcp"),
+  }),
+  z.object({
+    type: z.literal("static"),
+    /**
+     * The IPv4 address to assign to the virtual machine.
+     */
+    address: z.string().optional(),
+    /**
+     * The CIDR prefix for the IPv4 address.
+     */
+    prefix: z.number().default(24),
+  }),
+]).default({ type: "dhcp" })`
+
+    const result = await applySchemaTransformations(input)
+
+    expect(result).toContain(
+      'address: z.string().optional().meta({ title: __camelCaseToHumanReadable("address"), description: `The IPv4 address to assign to the virtual machine.` })',
+    )
+    expect(result).toContain(
+      'prefix: z.number().default(24).meta({ title: __camelCaseToHumanReadable("prefix"), description: `The CIDR prefix for the IPv4 address.` })',
+    )
+    expect(result).toContain('type: z.literal("dhcp"),') // unchanged, no comment
+    expect(result).toContain('type: z.literal("static"),') // unchanged, no comment
+  })
+
+  it("should handle the full defineUnit case with discriminated union and mixed transformations", async () => {
+    const input = `
+var virtualMachine = defineUnit({
+  type: "proxmox.virtual-machine",
+  args: {
+    nodeName: z.string().optional(),
+    cpuType: z.string().default("host"),
+    cores: z.number().default(1),
+    sockets: z.number().default(1),
+    memory: z.number().default(512),
+    /**
+     * The IPv4 address configuration for the virtual machine.
+     */
+    ipv4: {
+      schema: z.discriminatedUnion("type", [
+        z.object({
+          type: z.literal("dhcp")
+        }),
+        z.object({
+          type: z.literal("static"),
+          /**
+           * The IPv4 address to assign to the virtual machine.
+           */
+          address: z.string().optional(),
+          /**
+           * The CIDR prefix for the IPv4 address.
+           *
+           * By default, this is set to 24.
+           */
+          prefix: z.number().default(24),
+          /**
+           * The IPv4 gateway for the virtual machine.
+           *
+           * If not specified, will be set to the first address in the subnet.
+           */
+          gateway: z.string().optional()
+        })
+      ]).default({ type: "dhcp" })
+    },
+    dns: z.string().array().optional(),
+    datastoreId: z.string().optional(),
+    diskSize: z.number().default(8),
+    bridge: z.string().default("vmbr0"),
+    sshPort: z.number().default(22),
+    sshUser: z.string().default("root"),
+    waitForAgent: z.boolean().default(true),
+    vendorData: z.string().optional()
+  },
+  secrets: {
+    sshPassword: z.string().optional()
+  },
+  inputs: {
+    proxmoxCluster: clusterEntity,
+    image: imageEntity,
+    sshKeyPair: {
+      entity: keyPairEntity,
+      required: false
+    },
+    /**
+     * The cloud-init vendor data to use for the virtual machine.
+     *
+     * You can provide a cloud-config from the distribution component.
+     */
+    vendorData: {
+      entity: fileEntity,
+      required: false,
+    }
+  },
+  outputs: serverOutputs,
+  meta: {
+    title: "Proxmox Virtual Machine",
+    description: "The virtual machine on a Proxmox cluster.",
+    category: "Proxmox",
+    icon: "simple-icons:proxmox",
+    iconColor: "#e56901",
+    secondaryIcon: "codicon:vm"
+  },
+  source: {
+    package: "@highstate/proxmox",
+    path: "virtual-machine"
+  }
+});`
+
+    const result = await applySchemaTransformations(input)
+
+    // Should transform args.ipv4 to entity/schema structure (existing transformer behavior)
+    expect(result).toContain("ipv4: {")
+    expect(result).toContain("schema: z.discriminatedUnion")
+    expect(result).toContain("meta: {")
+    expect(result).toContain(
+      "description: `The IPv4 address configuration for the virtual machine.`",
+    )
+
+    // Should add .meta() to z.object fields with JSDoc comments inside the discriminated union
+    expect(result).toContain(
+      'address: z.string().optional().meta({ title: __camelCaseToHumanReadable("address"), description: `The IPv4 address to assign to the virtual machine.` })',
+    )
+    expect(result).toContain(
+      'prefix: z.number().default(24).meta({ title: __camelCaseToHumanReadable("prefix"), description: `The CIDR prefix for the IPv4 address.',
+    )
+    expect(result).toContain("By default, this is set to 24.` })")
+    expect(result).toContain(
+      'gateway: z.string().optional().meta({ title: __camelCaseToHumanReadable("gateway"), description: `The IPv4 gateway for the virtual machine.',
+    )
+    expect(result).toContain(
+      "If not specified, will be set to the first address in the subnet.` })",
+    )
+
+    // Should NOT transform fields without JSDoc comments
+    expect(result).toContain("nodeName: z.string().optional(),") // unchanged
+    expect(result).toContain('cpuType: z.string().default("host"),') // unchanged
+    expect(result).toContain("cores: z.number().default(1),") // unchanged
+    expect(result).toContain("dns: z.string().array().optional(),") // unchanged
+    expect(result).toContain('type: z.literal("dhcp")') // unchanged
+    expect(result).toContain('type: z.literal("static"),') // unchanged
+
+    // Should properly handle inputs.vendorData with existing meta (no change expected since it already has meta)
+    expect(result).toContain("vendorData: {")
+    expect(result).toContain("entity: fileEntity,")
+    expect(result).toContain("required: false,")
+    expect(result).toContain("You can provide a cloud-config from the distribution component.")
+
+    // Should NOT transform other inputs without JSDoc
+    expect(result).toContain("proxmoxCluster: clusterEntity,") // unchanged
+    expect(result).toContain("image: imageEntity,") // unchanged
+  })
 })

package/src/shared/schema-transformer.ts

@@ -18,15 +18,45 @@ export const schemaTransformerPlugin: Plugin = {
   },
 }
 
+type Transformation = {
+  start: number
+  end: number
+  newValue: string
+  type: "zod-meta" | "schema-structure" | "import"
+}
+
 export async function applySchemaTransformations(content: string): Promise<string> {
-  const magicString = new MagicString(content)
   const { program, comments } = await parseAsync("file.ts", content)
 
+  const transformations: Transformation[] = []
   const parentStack: Node[] = []
 
   walk(program, {
     enter(node) {
-      parentStack.push(node)
+      parentStack.push(node) // Handle z.object() patterns
+      if (
+        node.type === "Property" &&
+        node.key.type === "Identifier" &&
+        isInsideZodObject(parentStack)
+      ) {
+        const jsdoc = comments.find(comment => isLeadingComment(content, node, comment))
+        if (jsdoc) {
+          const description = cleanJsdoc(jsdoc.value)
+          const fieldName = node.key.name
+          const originalValue = content.substring(node.value.start, node.value.end)
+
+          // Check if the field already has .meta() call
+          if (!originalValue.includes(".meta(")) {
+            transformations.push({
+              start: node.value.start,
+              end: node.value.end,
+              newValue: `${originalValue}.meta({ title: __camelCaseToHumanReadable("${fieldName}"), description: \`${description}\` })`,
+              type: "zod-meta",
+            })
+          }
+        }
+        return
+      }
 
       if (node.type !== "Property" || node.key.type !== "Identifier") {
         return
@@ -53,27 +83,132 @@ export async function applySchemaTransformations(content: string): Promise<strin
       if (isAlreadyStructured) {
         // For already structured values, inject description directly into the object
         const modifiedValue = injectDescriptionIntoObject(originalValue, description)
-        magicString.update(node.value.start, node.value.end, modifiedValue)
+        transformations.push({
+          start: node.value.start,
+          end: node.value.end,
+          newValue: modifiedValue,
+          type: "schema-structure",
+        })
       } else {
         // Transform to new structure
-        magicString.update(
-          node.value.start,
-          node.value.end,
-          `{
+        transformations.push({
+          start: node.value.start,
+          end: node.value.end,
+          newValue: `{
   ${entityField}: ${originalValue},
   meta: {
     description: \`${description}\`,
   },
 }`,
-        )
+          type: "schema-structure",
+        })
       }
     },
     leave() {
       parentStack.pop()
     },
+  }) // Handle overlapping transformations by merging them
+  const zodMetaTransformations = transformations.filter(t => t.type === "zod-meta")
+  const schemaTransformations = transformations.filter(t => t.type === "schema-structure")
+
+  // For each schema transformation, check if it contains zod-meta transformations
+  const processedSchemaTransformations = schemaTransformations.map(schemaTransform => {
+    const containedZodMetas = zodMetaTransformations.filter(zodTransform => {
+      return schemaTransform.start <= zodTransform.start && schemaTransform.end >= zodTransform.end
+    })
+
+    if (containedZodMetas.length > 0) {
+      // Apply the zod-meta transformations to the original content first
+      const originalContent = content.substring(schemaTransform.start, schemaTransform.end)
+      const tempMagicString = new MagicString(originalContent)
+
+      // Adjust positions relative to the schema transformation start
+      containedZodMetas
+        .sort((a, b) => b.start - a.start)
+        .forEach(zodTransform => {
+          const relativeStart = zodTransform.start - schemaTransform.start
+          const relativeEnd = zodTransform.end - schemaTransform.start
+          tempMagicString.update(relativeStart, relativeEnd, zodTransform.newValue)
+        })
+
+      const modifiedContent = tempMagicString.toString()
+
+      // Now create the schema transformation with the modified content
+      const entityField = schemaTransform.newValue.includes("entity:") ? "entity" : "schema"
+      const descriptionMatch = schemaTransform.newValue.match(/description: `([^`]+)`/)
+
+      if (descriptionMatch) {
+        const description = descriptionMatch[1]
+
+        // Check if the original content is already structured
+        const isAlreadyStructured = isStructuredValue(
+          content.substring(schemaTransform.start, schemaTransform.end),
+          entityField,
+        )
+
+        if (isAlreadyStructured) {
+          // Just inject the description into the existing structure with modified content
+          return {
+            ...schemaTransform,
+            newValue: injectDescriptionIntoObject(modifiedContent, description),
+            containsZodMeta: true,
+          }
+        } else {
+          // Create new structure with modified content
+          return {
+            ...schemaTransform,
+            newValue: `{
+  ${entityField}: ${modifiedContent},
+  meta: {
+    description: \`${description}\`,
+  },
+}`,
+            containsZodMeta: true,
+          }
+        }
+      }
+    }
+
+    return { ...schemaTransform, containsZodMeta: false }
+  })
+
+  // Filter out zod-meta transformations that are already included in schema transformations
+  const independentZodMetas = zodMetaTransformations.filter(zodTransform => {
+    return !schemaTransformations.some(schemaTransform => {
+      return schemaTransform.start <= zodTransform.start && schemaTransform.end >= zodTransform.end
+    })
   })
 
-  return magicString.toString()
+  // Combine the transformations
+  const finalTransformations = [
+    ...independentZodMetas,
+    ...processedSchemaTransformations.map(({ containsZodMeta, ...rest }) => rest), // eslint-disable-line @typescript-eslint/no-unused-vars
+  ]
+
+  // Check if we need to add the import for camelCaseToHumanReadable
+  const hasZodMetaTransformations = zodMetaTransformations.length > 0
+  const needsImport = hasZodMetaTransformations && !content.includes("__camelCaseToHumanReadable")
+
+  let result = content
+  const magicString = new MagicString(result)
+
+  // Apply all transformations
+  finalTransformations
+    .sort((a, b) => b.start - a.start) // Sort in reverse order by start position
+    .forEach(transformation => {
+      magicString.update(transformation.start, transformation.end, transformation.newValue)
+    })
+
+  result = magicString.toString()
+
+  // Add import at the beginning if needed
+  if (needsImport) {
+    result =
+      'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"\n' +
+      result
+  }
+
+  return result
 }
 
 function injectDescriptionIntoObject(objectString: string, description: string): string {
@@ -83,12 +218,20 @@ function injectDescriptionIntoObject(objectString: string, description: string):
   const metaRegex = /meta\s*:\s*\{/
 
   if (metaRegex.test(trimmed)) {
-    // Find the meta field and inject description into it
-    return trimmed.replace(
-      /meta\s*:\s*\{/,
-      `meta: {
+    // Check if the meta field already has a description
+    const hasDescription = /meta\s*:\s*\{[^}]*description\s*:/.test(trimmed)
+
+    if (hasDescription) {
+      // Replace existing description
+      return trimmed.replace(/description\s*:\s*`[^`]*`/, `description: \`${description}\``)
+    } else {
+      // Add description at the beginning of the meta object
+      return trimmed.replace(
+        /meta\s*:\s*\{/,
+        `meta: {
     description: \`${description}\`,`,
-    )
+      )
+    }
   } else {
     // Add meta field at the end of the object (before the closing brace)
     const lastBraceIndex = trimmed.lastIndexOf("}")
@@ -174,3 +317,71 @@ function cleanJsdoc(str: string) {
       .trim()
   )
 }
+
+function isInsideZodObject(parentStack: Node[]): boolean {
+  // Look for z.object() call expression in the parent stack
+  for (let i = parentStack.length - 1; i >= 0; i--) {
+    const node = parentStack[i]
+    if (
+      node.type === "CallExpression" &&
+      node.callee.type === "MemberExpression" &&
+      isZodObjectCall(node.callee)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+function isZodObjectCall(memberExpression: Node): boolean {
+  if (memberExpression.type !== "MemberExpression") {
+    return false
+  }
+
+  // Handle direct z.object() calls
+  if (
+    memberExpression.object.type === "Identifier" &&
+    memberExpression.object.name === "z" &&
+    memberExpression.property.type === "Identifier" &&
+    memberExpression.property.name === "object"
+  ) {
+    return true
+  }
+
+  // Handle chained calls like z.discriminatedUnion().default().object()
+  // or any other chained Zod methods that end with .object()
+  if (
+    memberExpression.property.type === "Identifier" &&
+    memberExpression.property.name === "object" &&
+    memberExpression.object.type === "CallExpression" &&
+    memberExpression.object.callee.type === "MemberExpression"
+  ) {
+    // Recursively check if this is part of a z.* chain
+    return startsWithZodCall(memberExpression.object)
+  }
+
+  return false
+}
+
+function startsWithZodCall(callExpression: Node): boolean {
+  if (!callExpression || callExpression.type !== "CallExpression") {
+    return false
+  }
+
+  if (callExpression.callee.type === "MemberExpression") {
+    // Check if this is a direct z.* call
+    if (
+      callExpression.callee.object.type === "Identifier" &&
+      callExpression.callee.object.name === "z"
+    ) {
+      return true
+    }
+
+    // Recursively check nested calls
+    if (callExpression.callee.object.type === "CallExpression") {
+      return startsWithZodCall(callExpression.callee.object)
+    }
+  }
+
+  return false
+}

package/src/shared/source-hash-calculator.ts

@@ -6,7 +6,6 @@ import { readPackageJSON, resolvePackageJSON, type PackageJson } from "pkg-types
 import { crc32 } from "@aws-crypto/crc32"
 import { resolve as importMetaResolve } from "import-meta-resolve"
 import { z } from "zod"
-import { int32ToBytes } from "@highstate/backend/shared"
 import {
   type HighstateManifest,
   type HighstateConfig,
@@ -15,6 +14,7 @@ import {
   highstateManifestSchema,
   sourceHashConfigSchema,
 } from "./schemas"
+import { int32ToBytes } from "./utils"
 
 type FileDependency =
   | {

package/src/shared/utils.ts

@@ -0,0 +1,6 @@
+export function int32ToBytes(value: number): Uint8Array {
+  const buffer = new ArrayBuffer(4)
+  const view = new DataView(buffer)
+  view.setInt32(0, value, true) // true for little-endian
+  return new Uint8Array(buffer)
+}

package/dist/library-loader-CGEPTS4L.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/shared/library-loader.ts"],"sourcesContent":["import type { Logger } from \"pino\"\nimport {\n  type Component,\n  type ComponentModel,\n  type Entity,\n  isComponent,\n  isEntity,\n  isUnitModel,\n  originalCreate,\n} from \"@highstate/contract\"\nimport { serializeFunction } from \"@pulumi/pulumi/runtime/index.js\"\nimport { Crc32, crc32 } from \"@aws-crypto/crc32\"\nimport { encode } from \"@msgpack/msgpack\"\nimport { int32ToBytes } from \"@highstate/backend/shared\"\n\nexport type Library = Readonly<{\n  components: Readonly<Record<string, ComponentModel>>\n  entities: Readonly<Record<string, Entity>>\n}>\n\nexport async function loadLibrary(logger: Logger, modulePaths: string[]): Promise<Library> {\n  const modules: Record<string, unknown> = {}\n  for (const modulePath of modulePaths) {\n    try {\n      logger.debug({ modulePath }, \"loading module\")\n      modules[modulePath] = await import(modulePath)\n\n      logger.debug({ modulePath }, \"module loaded\")\n    } catch (err) {\n      logger.error({ modulePath, err }, \"module load failed\")\n    }\n  }\n\n  const components: Record<string, ComponentModel> = {}\n  const entities: Record<string, Entity> = {}\n\n  await _loadLibrary(modules, components, entities)\n\n  logger.info(\n    {\n      componentCount: Object.keys(components).length,\n      entityCount: Object.keys(entities).length,\n    },\n    \"library loaded\",\n  )\n\n  logger.trace({ components, entities }, \"library content\")\n\n  return { components, entities }\n}\n\nasync function _loadLibrary(\n  value: unknown,\n  components: Record<string, ComponentModel>,\n  entities: Record<string, Entity>,\n): Promise<void> {\n  if (isComponent(value)) {\n    const entityHashes: number[] = []\n    for (const entity of value.entities.values()) {\n      entity.definitionHash ??= calculateEntityDefinitionHash(entity)\n      entityHashes.push(entity.definitionHash)\n    }\n\n    components[value.model.type] = value.model\n    value.model.definitionHash = await calculateComponentDefinitionHash(value, entityHashes)\n\n    return\n  }\n\n  if (isEntity(value)) {\n    entities[value.type] = value\n    entities[value.type].definitionHash ??= calculateEntityDefinitionHash(value)\n\n    // @ts-expect-error remove the schema since it's not needed in the designer\n    delete value.schema\n    return\n  }\n\n  if (typeof value !== \"object\" || value === null) {\n    return\n  }\n\n  for (const key in value) {\n    await _loadLibrary((value as Record<string, unknown>)[key], components, entities)\n  }\n}\n\nasync function calculateComponentDefinitionHash(\n  component: Component,\n  entityHashes: number[],\n): Promise<number> {\n  const result = new Crc32()\n\n  // 1. include the full component model\n  result.update(encode(component.model))\n\n  if (!isUnitModel(component.model)) {\n    // 2. for composite components, include the content of the serialized create function\n    const serializedCreate = await serializeFunction(component[originalCreate])\n    result.update(Buffer.from(serializedCreate.text))\n  }\n\n  // 3. include the hashes of all entities\n  for (const entityHash of entityHashes) {\n    result.update(int32ToBytes(entityHash))\n  }\n\n  return result.digest()\n}\n\nfunction calculateEntityDefinitionHash(entity: Entity): number {\n  return crc32(encode(entity))\n}\n"],"mappings":";AACA;AAAA,EAIE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,OAAO,aAAa;AAC7B,SAAS,cAAc;AACvB,SAAS,oBAAoB;AAO7B,eAAsB,YAAY,QAAgB,aAAyC;AACzF,QAAM,UAAmC,CAAC;AAC1C,aAAW,cAAc,aAAa;AACpC,QAAI;AACF,aAAO,MAAM,EAAE,WAAW,GAAG,gBAAgB;AAC7C,cAAQ,UAAU,IAAI,MAAM,OAAO;AAEnC,aAAO,MAAM,EAAE,WAAW,GAAG,eAAe;AAAA,IAC9C,SAAS,KAAK;AACZ,aAAO,MAAM,EAAE,YAAY,IAAI,GAAG,oBAAoB;AAAA,IACxD;AAAA,EACF;AAEA,QAAM,aAA6C,CAAC;AACpD,QAAM,WAAmC,CAAC;AAE1C,QAAM,aAAa,SAAS,YAAY,QAAQ;AAEhD,SAAO;AAAA,IACL;AAAA,MACE,gBAAgB,OAAO,KAAK,UAAU,EAAE;AAAA,MACxC,aAAa,OAAO,KAAK,QAAQ,EAAE;AAAA,IACrC;AAAA,IACA;AAAA,EACF;AAEA,SAAO,MAAM,EAAE,YAAY,SAAS,GAAG,iBAAiB;AAExD,SAAO,EAAE,YAAY,SAAS;AAChC;AAEA,eAAe,aACb,OACA,YACA,UACe;AACf,MAAI,YAAY,KAAK,GAAG;AACtB,UAAM,eAAyB,CAAC;AAChC,eAAW,UAAU,MAAM,SAAS,OAAO,GAAG;AAC5C,aAAO,mBAAmB,8BAA8B,MAAM;AAC9D,mBAAa,KAAK,OAAO,cAAc;AAAA,IACzC;AAEA,eAAW,MAAM,MAAM,IAAI,IAAI,MAAM;AACrC,UAAM,MAAM,iBAAiB,MAAM,iCAAiC,OAAO,YAAY;AAEvF;AAAA,EACF;AAEA,MAAI,SAAS,KAAK,GAAG;AACnB,aAAS,MAAM,IAAI,IAAI;AACvB,aAAS,MAAM,IAAI,EAAE,mBAAmB,8BAA8B,KAAK;AAG3E,WAAO,MAAM;AACb;AAAA,EACF;AAEA,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C;AAAA,EACF;AAEA,aAAW,OAAO,OAAO;AACvB,UAAM,aAAc,MAAkC,GAAG,GAAG,YAAY,QAAQ;AAAA,EAClF;AACF;AAEA,eAAe,iCACb,WACA,cACiB;AACjB,QAAM,SAAS,IAAI,MAAM;AAGzB,SAAO,OAAO,OAAO,UAAU,KAAK,CAAC;AAErC,MAAI,CAAC,YAAY,UAAU,KAAK,GAAG;AAEjC,UAAM,mBAAmB,MAAM,kBAAkB,UAAU,cAAc,CAAC;AAC1E,WAAO,OAAO,OAAO,KAAK,iBAAiB,IAAI,CAAC;AAAA,EAClD;AAGA,aAAW,cAAc,cAAc;AACrC,WAAO,OAAO,aAAa,UAAU,CAAC;AAAA,EACxC;AAEA,SAAO,OAAO,OAAO;AACvB;AAEA,SAAS,8BAA8B,QAAwB;AAC7D,SAAO,MAAM,OAAO,MAAM,CAAC;AAC7B;","names":[]}