marko 6.0.161 → 6.0.163

package/dist/common/helpers.d.ts

@@ -6,6 +6,5 @@ export declare function styleValue(styleValue: unknown): string;
 export declare function isEventHandler(name: string): name is `on${string}`;
 export declare function getEventHandlerName(name: `on${string}`): string;
 export declare function isVoid(value: unknown): value is false | null | undefined;
-export declare function alphaEncode(num: number): string;
 export declare function normalizeDynamicRenderer<Renderer>(value: any): Renderer | string | undefined;
 export declare const decodeAccessor: (num: number) => string;

package/dist/common/types.d.ts

@@ -2,7 +2,6 @@ import type { PendingRender } from "../dom/queue";
 import type { Renderer as ClientRenderer, Renderer } from "../dom/renderer";
 import type { AccessorProp } from "./accessor.debug";
 export type Falsy = undefined | null | false | 0 | "";
-export type CommentWalker = TreeWalker & Record<string, Comment>;
 export interface BranchScope extends Scope {
     [AccessorProp.StartNode]: ChildNode;
     [AccessorProp.EndNode]: ChildNode;

package/dist/debug/dom.js

@@ -620,7 +620,7 @@ function _closure(...closureSignals) {
         if (!childScope["#Creating" /* Creating */]) {
           queueRender(
             childScope,
-            closureSignals[childScope[___signalIndexAccessor]],
+            closureSignals[childScope[___signalIndexAccessor] || 0],
             -1
           );
         }

package/dist/debug/dom.mjs

@@ -504,7 +504,7 @@ function _closure(...closureSignals) {
         if (!childScope["#Creating" /* Creating */]) {
           queueRender(
             childScope,
-            closureSignals[childScope[___signalIndexAccessor]],
+            closureSignals[childScope[___signalIndexAccessor] || 0],
             -1
           );
         }

package/dist/dom/dom.d.ts

@@ -1,8 +1,6 @@
 import { type Accessor, type Scope } from "../common/types";
-import { type Renderer } from "./renderer";
 export declare function _to_text(value: unknown): string;
 export declare function _attr(element: Element, name: string, value: unknown): void;
-export declare function setAttribute(element: Element, name: string, value: string | undefined): void;
 export declare function _attr_class(element: Element, value: unknown): void;
 export declare function _attr_class_items(element: Element, items: Record<string, unknown>): void;
 export declare function _attr_class_item(element: Element, name: string, value: unknown): void;
@@ -19,7 +17,6 @@ export declare function _attrs_partial_content(scope: Scope, nodeAccessor: Acces
 export declare function _attr_content(scope: Scope, nodeAccessor: Accessor, value: unknown): void;
 export declare function _attrs_script(scope: Scope, nodeAccessor: Accessor): void;
 export declare function _html(scope: Scope, value: unknown, accessor: Accessor): void;
-export declare function normalizeClientRender(value: any): Renderer | undefined;
 export declare function normalizeAttrValue(value: unknown): string | undefined;
 export declare function _lifecycle(scope: Scope, thisObj: Record<string, unknown> & {
     onMount?: (this: unknown) => void;

package/dist/dom.js

@@ -382,7 +382,7 @@ function _closure(...closureSignals) {
       for (let childScope of scope[___scopeInstancesAccessor])
         childScope.H || queueRender(
           childScope,
-          closureSignals[childScope[___signalIndexAccessor]],
+          closureSignals[childScope[___signalIndexAccessor] || 0],
           -1
         );
   };

package/dist/dom.mjs

@@ -269,7 +269,7 @@ function _closure(...closureSignals) {
       for (let childScope of scope[___scopeInstancesAccessor])
         childScope.H || queueRender(
           childScope,
-          closureSignals[childScope[___signalIndexAccessor]],
+          closureSignals[childScope[___signalIndexAccessor] || 0],
           -1
         );
   };

package/dist/html/attrs.d.ts

@@ -15,5 +15,3 @@ export declare function _attrs_content(data: Record<string, unknown>, nodeAccess
 export declare function _attrs_partial(data: Record<string, unknown>, skip: Record<string, 1>, nodeAccessor: Accessor, scopeId: number, tagName: string): string;
 export declare function _attrs_partial_content(data: Record<string, unknown>, skip: Record<string, 1>, nodeAccessor: Accessor, scopeId: number, tagName: string, serializeReason?: 1 | 0): void;
 export declare function attrAssignment(value: string): string;
-export declare function escapeSingleQuotedAttrValue(value: string): string;
-export declare function escapeDoubleQuotedAttrValue(value: string): string;

package/dist/html/for.d.ts

@@ -1,4 +1,5 @@
 export { forIn, forOf, forTo, forUntil } from "../common/for";
-export declare function forOfBy(by: unknown, item: any, index: unknown): any;
-export declare function forInBy(by: unknown, name: string, value: unknown): any;
-export declare function forStepBy(by: unknown, index: number): any;
+import type { Falsy } from "../common/types";
+export declare function forOfBy(by: Falsy | string | ((item: unknown, index: number) => unknown), item: unknown, index: number): unknown;
+export declare function forInBy(by: Falsy | ((key: string, value: unknown) => unknown), name: string, value: unknown): unknown;
+export declare function forStepBy(by: Falsy | ((index: number) => unknown), index: number): unknown;

package/dist/html/template.d.ts

@@ -4,4 +4,3 @@ export type ServerRenderer = ((...args: unknown[]) => unknown) & {
     ___embed?: boolean;
 };
 export declare const _template: (templateId: string, renderer: ServerRenderer, page?: 1) => Template;
-export declare function isTemplate(renderer: ServerRenderer | Template): renderer is ServerRenderer & Template;

package/dist/html/writer.d.ts

@@ -1,7 +1,6 @@
 import { _hoist_read_error } from "../common/errors";
 import { type $Global, type Accessor, type Falsy, ResumeSymbol } from "../common/types";
 import { Serializer } from "./serializer";
-import type { ServerRenderer } from "./template";
 export type PartialScope = Record<Accessor, unknown>;
 type ScopeInternals = PartialScope & {
     [K_SCOPE_ID]?: number;
@@ -22,7 +21,6 @@ export declare function _html(html: string): void;
 export declare function writeScript(script: string): void;
 export declare function _script(scopeId: number, registryId: string): void;
 export declare function _attr_content(nodeAccessor: Accessor, scopeId: number, content: unknown, serializeReason?: 1 | 0): void;
-export declare function normalizeServerRender(value: unknown): ServerRenderer | undefined;
 export declare function withContext<T>(key: PropertyKey, value: unknown, cb: () => T): T;
 export declare function withContext<T, U>(key: PropertyKey, value: unknown, cb: (value: U) => T, cbValue: U): T;
 export declare function _var(parentScopeId: number, scopeOffsetAccessor: Accessor, childScopeId: number, registryId: string): void;

package/dist/translator/core/for.d.ts

@@ -1,62 +1,7 @@
 import { types as t } from "@marko/compiler";
+import { type Tag } from "@marko/compiler/babel-utils";
 type ForType = "in" | "of" | "to" | "until";
-declare const _default: {
-    analyze(tag: t.NodePath<t.MarkoTag>): void;
-    translate: {
-        readonly enter: (path: t.NodePath<t.MarkoTag>) => void;
-        readonly exit: (path: t.NodePath<t.MarkoTag>) => void;
-    };
-    parseOptions: {
-        controlFlow: true;
-    };
-    attributes: {
-        of: {
-            type: string;
-            autocomplete: {
-                description: string;
-            }[];
-        };
-        in: {
-            type: string;
-            autocomplete: {
-                description: string;
-            }[];
-        };
-        to: {
-            type: string;
-            autocomplete: {
-                description: string;
-            }[];
-        };
-        until: {
-            type: string;
-            autocomplete: {
-                description: string;
-            }[];
-        };
-        from: {
-            type: string;
-            autocomplete: {
-                description: string;
-            }[];
-        };
-        step: {
-            type: string;
-            autocomplete: {
-                description: string;
-            }[];
-        };
-    };
-    autocomplete: ({
-        snippet: string;
-        description: string;
-        descriptionMoreURL: string;
-    } | {
-        snippet: string;
-        descriptionMoreURL: string;
-        description?: undefined;
-    })[];
-};
+declare const _default: Tag;
 export default _default;
 export declare function buildForRuntimeCall(type: ForType, attrs: Record<string, t.Expression>, params: t.ArrowFunctionExpression["params"], statements: t.Statement[]): t.ExpressionStatement;
 export declare function getForType(tag: t.MarkoTag): ForType | undefined;

package/dist/translator/core/if.d.ts

@@ -1,32 +1,47 @@
 import { types as t } from "@marko/compiler";
-export declare const IfTag: {
-    analyze(tag: t.NodePath<t.MarkoTag>): void;
-    translate: {
-        readonly enter: (path: t.NodePath<t.MarkoTag>) => void;
-        readonly exit: (path: t.NodePath<t.MarkoTag>) => void;
-    };
-    parseOptions: {
-        controlFlow: true;
-    };
-    autocomplete: {
-        snippet: string;
-        description: string;
-        descriptionMoreURL: string;
-    }[];
-};
+import { type Tag } from "@marko/compiler/babel-utils";
+export declare const IfTag: Tag;
 export declare const ElseIfTag: {
     autocomplete: {
         snippet: string;
         description: string;
         descriptionMoreURL: string;
     }[];
-    analyze(tag: t.NodePath<t.MarkoTag>): void;
-    translate: {
-        readonly enter: (path: t.NodePath<t.MarkoTag>) => void;
-        readonly exit: (path: t.NodePath<t.MarkoTag>) => void;
+    attributeGroups?: string[];
+    patternAttributes?: import("@marko/compiler/babel-utils").Attribute[];
+    attributes?: {
+        [x: string]: import("@marko/compiler/babel-utils").Attribute;
     };
-    parseOptions: {
-        controlFlow: true;
+    description?: string;
+    nestedTags?: {
+        [x: string]: Tag & {
+            isRepeated?: boolean;
+            targetProperty?: string;
+        };
+    };
+    htmlType?: "html" | "svg" | "math";
+    html?: boolean;
+    types?: string;
+    template?: string;
+    renderer?: string;
+    deprecated?: boolean;
+    openTagOnly?: boolean;
+    analyze?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>;
+    translate?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>;
+    parse?: import("@marko/compiler/babel-utils").ParsePlugin<t.MarkoTag>;
+    transform?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag> | import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>[];
+    migrate?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag> | import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>[];
+    parseOptions?: {
+        rootOnly?: boolean;
+        rawOpenTag?: boolean;
+        openTagOnly?: boolean;
+        controlFlow?: boolean;
+        ignoreAttributes?: boolean;
+        relaxRequireCommas?: boolean;
+        statement?: boolean;
+        preserveWhitespace?: boolean;
+        text?: boolean;
+        html?: boolean;
     };
 };
 export declare const ElseTag: {
@@ -34,12 +49,40 @@ export declare const ElseTag: {
         description: string;
         descriptionMoreURL: string;
     }[];
-    analyze(tag: t.NodePath<t.MarkoTag>): void;
-    translate: {
-        readonly enter: (path: t.NodePath<t.MarkoTag>) => void;
-        readonly exit: (path: t.NodePath<t.MarkoTag>) => void;
+    attributeGroups?: string[];
+    patternAttributes?: import("@marko/compiler/babel-utils").Attribute[];
+    attributes?: {
+        [x: string]: import("@marko/compiler/babel-utils").Attribute;
+    };
+    description?: string;
+    nestedTags?: {
+        [x: string]: Tag & {
+            isRepeated?: boolean;
+            targetProperty?: string;
+        };
     };
-    parseOptions: {
-        controlFlow: true;
+    htmlType?: "html" | "svg" | "math";
+    html?: boolean;
+    types?: string;
+    template?: string;
+    renderer?: string;
+    deprecated?: boolean;
+    openTagOnly?: boolean;
+    analyze?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>;
+    translate?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>;
+    parse?: import("@marko/compiler/babel-utils").ParsePlugin<t.MarkoTag>;
+    transform?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag> | import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>[];
+    migrate?: import("@marko/compiler/babel-utils").Plugin<t.MarkoTag> | import("@marko/compiler/babel-utils").Plugin<t.MarkoTag>[];
+    parseOptions?: {
+        rootOnly?: boolean;
+        rawOpenTag?: boolean;
+        openTagOnly?: boolean;
+        controlFlow?: boolean;
+        ignoreAttributes?: boolean;
+        relaxRequireCommas?: boolean;
+        statement?: boolean;
+        preserveWhitespace?: boolean;
+        text?: boolean;
+        html?: boolean;
     };
 };

package/dist/translator/core/index.d.ts

@@ -13,13 +13,41 @@ declare const _default: {
             description: string;
             descriptionMoreURL: string;
         }[];
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
+        attributeGroups?: string[];
+        patternAttributes?: import("@marko/compiler/babel-utils").Attribute[];
+        attributes?: {
+            [x: string]: import("@marko/compiler/babel-utils").Attribute;
         };
-        parseOptions: {
-            controlFlow: true;
+        description?: string;
+        nestedTags?: {
+            [x: string]: import("@marko/compiler/babel-utils").Tag & {
+                isRepeated?: boolean;
+                targetProperty?: string;
+            };
+        };
+        htmlType?: "html" | "svg" | "math";
+        html?: boolean;
+        types?: string;
+        template?: string;
+        renderer?: string;
+        deprecated?: boolean;
+        openTagOnly?: boolean;
+        analyze?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        translate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        parse?: import("@marko/compiler/babel-utils").ParsePlugin<import("@marko/compiler/babel-types").MarkoTag>;
+        transform?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        migrate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        parseOptions?: {
+            rootOnly?: boolean;
+            rawOpenTag?: boolean;
+            openTagOnly?: boolean;
+            controlFlow?: boolean;
+            ignoreAttributes?: boolean;
+            relaxRequireCommas?: boolean;
+            statement?: boolean;
+            preserveWhitespace?: boolean;
+            text?: boolean;
+            html?: boolean;
         };
     };
     "<else>": {
@@ -27,92 +55,50 @@ declare const _default: {
             description: string;
             descriptionMoreURL: string;
         }[];
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-        };
-        parseOptions: {
-            controlFlow: true;
-        };
-    };
-    "<export>": import("@marko/compiler/babel-utils").Tag;
-    "<for>": {
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-        };
-        parseOptions: {
-            controlFlow: true;
+        attributeGroups?: string[];
+        patternAttributes?: import("@marko/compiler/babel-utils").Attribute[];
+        attributes?: {
+            [x: string]: import("@marko/compiler/babel-utils").Attribute;
         };
-        attributes: {
-            of: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            in: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            to: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            until: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            from: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            step: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
+        description?: string;
+        nestedTags?: {
+            [x: string]: import("@marko/compiler/babel-utils").Tag & {
+                isRepeated?: boolean;
+                targetProperty?: string;
             };
         };
-        autocomplete: ({
-            snippet: string;
-            description: string;
-            descriptionMoreURL: string;
-        } | {
-            snippet: string;
-            descriptionMoreURL: string;
-            description?: undefined;
-        })[];
+        htmlType?: "html" | "svg" | "math";
+        html?: boolean;
+        types?: string;
+        template?: string;
+        renderer?: string;
+        deprecated?: boolean;
+        openTagOnly?: boolean;
+        analyze?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        translate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        parse?: import("@marko/compiler/babel-utils").ParsePlugin<import("@marko/compiler/babel-types").MarkoTag>;
+        transform?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        migrate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        parseOptions?: {
+            rootOnly?: boolean;
+            rawOpenTag?: boolean;
+            openTagOnly?: boolean;
+            controlFlow?: boolean;
+            ignoreAttributes?: boolean;
+            relaxRequireCommas?: boolean;
+            statement?: boolean;
+            preserveWhitespace?: boolean;
+            text?: boolean;
+            html?: boolean;
+        };
     };
+    "<export>": import("@marko/compiler/babel-utils").Tag;
+    "<for>": import("@marko/compiler/babel-utils").Tag;
     "<html-comment>": import("@marko/compiler/babel-utils").Tag;
     "<html-script>": import("@marko/compiler/babel-utils").Tag;
     "<html-style>": import("@marko/compiler/babel-utils").Tag;
     "<id>": import("@marko/compiler/babel-utils").Tag;
-    "<if>": {
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-        };
-        parseOptions: {
-            controlFlow: true;
-        };
-        autocomplete: {
-            snippet: string;
-            description: string;
-            descriptionMoreURL: string;
-        }[];
-    };
+    "<if>": import("@marko/compiler/babel-utils").Tag;
     "<import>": import("@marko/compiler/babel-utils").Tag;
     "<let>": import("@marko/compiler/babel-utils").Tag;
     "<lifecycle>": import("@marko/compiler/babel-utils").Tag;

package/dist/translator/index.d.ts

@@ -19,13 +19,41 @@ export declare const taglibs: (string | {
             description: string;
             descriptionMoreURL: string;
         }[];
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
+        attributeGroups?: string[];
+        patternAttributes?: import("@marko/compiler/babel-utils").Attribute[];
+        attributes?: {
+            [x: string]: import("@marko/compiler/babel-utils").Attribute;
         };
-        parseOptions: {
-            controlFlow: true;
+        description?: string;
+        nestedTags?: {
+            [x: string]: import("@marko/compiler/babel-utils").Tag & {
+                isRepeated?: boolean;
+                targetProperty?: string;
+            };
+        };
+        htmlType?: "html" | "svg" | "math";
+        html?: boolean;
+        types?: string;
+        template?: string;
+        renderer?: string;
+        deprecated?: boolean;
+        openTagOnly?: boolean;
+        analyze?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        translate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        parse?: import("@marko/compiler/babel-utils").ParsePlugin<import("@marko/compiler/babel-types").MarkoTag>;
+        transform?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        migrate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        parseOptions?: {
+            rootOnly?: boolean;
+            rawOpenTag?: boolean;
+            openTagOnly?: boolean;
+            controlFlow?: boolean;
+            ignoreAttributes?: boolean;
+            relaxRequireCommas?: boolean;
+            statement?: boolean;
+            preserveWhitespace?: boolean;
+            text?: boolean;
+            html?: boolean;
         };
     };
     "<else>": {
@@ -33,92 +61,50 @@ export declare const taglibs: (string | {
             description: string;
             descriptionMoreURL: string;
         }[];
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-        };
-        parseOptions: {
-            controlFlow: true;
-        };
-    };
-    "<export>": import("@marko/compiler/babel-utils").Tag;
-    "<for>": {
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-        };
-        parseOptions: {
-            controlFlow: true;
+        attributeGroups?: string[];
+        patternAttributes?: import("@marko/compiler/babel-utils").Attribute[];
+        attributes?: {
+            [x: string]: import("@marko/compiler/babel-utils").Attribute;
         };
-        attributes: {
-            of: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            in: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            to: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            until: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            from: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
-            };
-            step: {
-                type: string;
-                autocomplete: {
-                    description: string;
-                }[];
+        description?: string;
+        nestedTags?: {
+            [x: string]: import("@marko/compiler/babel-utils").Tag & {
+                isRepeated?: boolean;
+                targetProperty?: string;
             };
         };
-        autocomplete: ({
-            snippet: string;
-            description: string;
-            descriptionMoreURL: string;
-        } | {
-            snippet: string;
-            descriptionMoreURL: string;
-            description?: undefined;
-        })[];
+        htmlType?: "html" | "svg" | "math";
+        html?: boolean;
+        types?: string;
+        template?: string;
+        renderer?: string;
+        deprecated?: boolean;
+        openTagOnly?: boolean;
+        analyze?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        translate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>;
+        parse?: import("@marko/compiler/babel-utils").ParsePlugin<import("@marko/compiler/babel-types").MarkoTag>;
+        transform?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        migrate?: import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag> | import("@marko/compiler/babel-utils").Plugin<import("@marko/compiler/babel-types").MarkoTag>[];
+        parseOptions?: {
+            rootOnly?: boolean;
+            rawOpenTag?: boolean;
+            openTagOnly?: boolean;
+            controlFlow?: boolean;
+            ignoreAttributes?: boolean;
+            relaxRequireCommas?: boolean;
+            statement?: boolean;
+            preserveWhitespace?: boolean;
+            text?: boolean;
+            html?: boolean;
+        };
     };
+    "<export>": import("@marko/compiler/babel-utils").Tag;
+    "<for>": import("@marko/compiler/babel-utils").Tag;
     "<html-comment>": import("@marko/compiler/babel-utils").Tag;
     "<html-script>": import("@marko/compiler/babel-utils").Tag;
     "<html-style>": import("@marko/compiler/babel-utils").Tag;
     "<id>": import("@marko/compiler/babel-utils").Tag;
-    "<if>": {
-        analyze(tag: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>): void;
-        translate: {
-            readonly enter: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-            readonly exit: (path: import("@marko/compiler/babel-types").NodePath<import("@marko/compiler/babel-types").MarkoTag>) => void;
-        };
-        parseOptions: {
-            controlFlow: true;
-        };
-        autocomplete: {
-            snippet: string;
-            description: string;
-            descriptionMoreURL: string;
-        }[];
-    };
+    "<if>": import("@marko/compiler/babel-utils").Tag;
     "<import>": import("@marko/compiler/babel-utils").Tag;
     "<let>": import("@marko/compiler/babel-utils").Tag;
     "<lifecycle>": import("@marko/compiler/babel-utils").Tag;