marko 6.0.79 → 6.0.80

package/dist/translator/util/binding-prop-tree.d.ts

@@ -0,0 +1,8 @@
+import { type Binding } from "./references";
+export type BindingPropTree = {
+    binding: Binding;
+    props: {
+        [prop: string]: BindingPropTree;
+    } | undefined;
+};
+export declare function getBindingPropTree(binding: Binding): BindingPropTree;

package/dist/translator/util/generate-uid.d.ts

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
+import type { Section } from "./sections";
 export declare function generateUid(name?: string): string;
 export declare function generateUidIdentifier(name?: string): t.Identifier;
-export declare function getSharedUid(name: string): string;
+export declare function getSharedUid(name: string, section?: Section): string;
 export declare function usedSharedUid(name: string): boolean;
 export declare function getSharedUidIdentifier(name: string): t.Identifier;

package/dist/translator/util/known-tag.d.ts

@@ -0,0 +1,23 @@
+import { types as t } from "@marko/compiler";
+import type { BindingPropTree } from "./binding-prop-tree";
+import { type Binding } from "./references";
+import { type Section } from "./sections";
+interface KnownExprs {
+    known?: Record<string, KnownExprs>;
+    value?: t.NodeExtra;
+}
+declare const kChildScopeBinding: unique symbol;
+declare const kChildOffsetScopeBinding: unique symbol;
+declare const kKnownExprs: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface MarkoTagExtra {
+        [kChildScopeBinding]?: Binding;
+        [kChildOffsetScopeBinding]?: Binding;
+        [kKnownExprs]?: KnownExprs;
+    }
+}
+export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, contentSection: Section, propTree: BindingPropTree | undefined): void;
+export declare function knownTagTranslateHTML(tag: t.NodePath<t.MarkoTag>, tagIdentifier: t.Expression, contentSection: Section, propTree: BindingPropTree | undefined): void;
+export declare function knownTagTranslateDOM(tag: t.NodePath<t.MarkoTag>, propTree: BindingPropTree | undefined, getBindingIdentifier: (binding: Binding, preferedName?: string) => t.Identifier, callSetup: (section: Section, childBinding: Binding) => void): void;
+export declare function getTagRelativePath(tag: t.NodePath<t.MarkoTag>): string;
+export {};

package/dist/translator/util/nested-attribute-tags.d.ts

@@ -5,6 +5,7 @@ export type AttrTagLookup = Record<string, {
     repeated: boolean;
     group: AttrTagNames;
 }>;
+export type AttrTagGroup = AttrTagLookup[string]["group"];
 type AttrTagNames = string[];
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {

package/dist/translator/util/optional.d.ts

@@ -12,7 +12,7 @@ export declare class Sorted<T> {
     findIndex<U extends NonNullable<T>>(data: Opt<U>, item: U): number;
     isSuperset<U extends NonNullable<T>>(superset: Opt<U>, subset: Opt<U>): boolean;
 }
-export declare function push<T>(data: Opt<T>, item: T): Opt<T>;
+export declare function push<T>(data: Opt<T>, item: T): OneMany<T>;
 export declare function concat<T>(a: Opt<T>, b: Opt<T>): Opt<T>;
 export declare function size<T>(data: Opt<T>): number;
 export declare function filter<T>(data: Opt<T>, cb: (item: T) => boolean): Opt<T>;
@@ -25,3 +25,4 @@ export declare function filterMap<T, R>(data: Opt<T>, cb: (item: T) => undefined
 export declare function findSorted<T>(compare: Compare<T>, data: T[], item: T): T | undefined;
 export declare function findIndexSorted<T>(compare: Compare<T>, data: T[], item: T): number;
 export declare function addSorted<T, U extends T[]>(compare: Compare<T>, data: U, item: T): U;
+export declare function groupBy<T, U>(data: Opt<T>, cb: (item: T) => U): Map<U, OneMany<T>>;

package/dist/translator/util/references.d.ts

@@ -17,7 +17,7 @@ export declare enum BindingType {
 }
 export interface Sources {
     state: Opt<Binding>;
-    input: Opt<InputBinding>;
+    param: Opt<InputBinding | ParamBinding>;
 }
 export interface Binding {
     id: number;
@@ -43,6 +43,9 @@ export interface Binding {
 export interface InputBinding extends Binding {
     type: BindingType.input;
 }
+export interface ParamBinding extends Binding {
+    type: BindingType.param;
+}
 export type ReferencedBindings = Opt<Binding>;
 export type Intersection = Many<Binding>;
 type FnExtra = (t.FunctionExpressionExtra | t.ArrowFunctionExpressionExtra | t.FunctionDeclarationExtra) & {
@@ -87,7 +90,7 @@ export declare const intersectionMeta: WeakMap<Intersection, {
     scopeOffset: Binding | undefined;
 }>;
 export declare function setBindingDownstream(binding: Binding, expr: boolean | Opt<t.NodeExtra>): void;
-export declare function createSources(state: Sources["state"], input: Sources["input"]): Sources;
+export declare function createSources(state: Sources["state"], param: Sources["param"]): Sources;
 export declare function compareSources(a: Sources, b: Sources): number;
 export declare function mergeSources(a: undefined | Sources, b: undefined | Sources): Sources | undefined;
 export declare const bindingUtil: Sorted<Binding>;

package/dist/translator/util/sections.d.ts

@@ -1,7 +1,8 @@
 import { types as t } from "@marko/compiler";
 import type { AccessorPrefix } from "../../common/accessor.debug";
+import type { ParamSerializeReasonGroups } from "../visitors/program";
 import { Sorted } from "./optional";
-import type { Binding, ReferencedBindings } from "./references";
+import type { Binding, InputBinding, ParamBinding, ReferencedBindings } from "./references";
 import { type SerializeReason } from "./serialize-reasons";
 export declare enum ContentType {
     Comment = 0,
@@ -20,7 +21,7 @@ export interface Section {
         binding: Binding;
         prefix: AccessorPrefix;
     } | undefined;
-    params: undefined | Binding;
+    params: undefined | ParamBinding | InputBinding;
     referencedLocalClosures: ReferencedBindings;
     referencedClosures: ReferencedBindings;
     referencedHoists: ReferencedBindings;
@@ -28,6 +29,8 @@ export interface Section {
     hoisted: ReferencedBindings;
     serializeReason: undefined | SerializeReason;
     serializeReasons: Map<symbol, SerializeReason>;
+    paramReasonGroups: ParamSerializeReasonGroups | undefined;
+    returnSerializeReason: SerializeReason | undefined;
     isHoistThrough: true | undefined;
     upstreamExpression: t.NodeExtra | undefined;
     downstreamBinding: Binding | undefined;

package/dist/translator/util/serialize-guard.d.ts

@@ -0,0 +1,5 @@
+import { types as t } from "@marko/compiler";
+import type { SerializeReason, SerializeReasons } from "./serialize-reasons";
+export declare function getSerializeGuard(reason: undefined | SerializeReason, optional: boolean): t.Expression | undefined;
+export declare function getSerializeGuardForAny(reasons: undefined | SerializeReasons, optional: boolean): t.Expression | undefined;
+export declare function getExprIfSerialized<T extends undefined | SerializeReason, U extends t.Expression>(reason: T, expr: U): T extends {} ? U : undefined;

package/dist/translator/util/serialize-reasons.d.ts

@@ -1,7 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { AccessorPrefix, AccessorProp } from "../../common/types";
-import { type Opt } from "./optional";
-import { type Binding, type ReferencedBindings, type Sources } from "./references";
+import { type OneMany, type Opt } from "./optional";
+import { type Binding, type InputBinding, type ParamBinding, type ReferencedBindings, type Sources } from "./references";
 import type { Section } from "./sections";
 export type SerializeReasons = true | [Sources, ...Sources[]];
 export type SerializeReason = true | Sources;
@@ -14,6 +14,10 @@ export declare function forceSectionSerialize(section: Section, prop?: AccessorP
 export declare function forceBindingSerialize(section: Section, binding: Binding, prefix?: AccessorPrefix | symbol): void;
 export declare function isSectionForceSerialized(section: Section, prop?: AccessorProp | symbol): boolean;
 export declare function isBindingForceSerialized(section: Section, binding: Binding, prefix?: AccessorPrefix | symbol): boolean;
+export declare function isReasonDynamic(reason: undefined | SerializeReason): reason is {
+    state: undefined;
+    param: OneMany<InputBinding | ParamBinding>;
+};
 export declare function addSectionSerializeReasonExpr(section: Section, expr: undefined | boolean | Opt<t.NodeExtra>, prop?: AccessorProp | symbol): void;
 export declare function addBindingSerializeReasonExpr(section: Section, binding: Binding, expr: undefined | boolean | Opt<t.NodeExtra>, prefix?: AccessorPrefix | symbol): void;
 export declare function addSectionSerializeReasonRef(section: Section, ref: undefined | boolean | ReferencedBindings, prop?: AccessorProp | symbol): void;

package/dist/translator/util/signals.d.ts

@@ -8,7 +8,7 @@ export type Signal = {
     valueAccessor?: t.Expression;
     referencedBindings: ReferencedBindings;
     section: Section;
-    build: undefined | (() => t.Expression);
+    build: undefined | (() => t.Expression | undefined);
     register?: boolean;
     values: Array<{
         signal: Signal;
@@ -34,6 +34,7 @@ export declare const getHTMLSectionStatements: (section: Section) => t.Statement
 export declare function getHoistFunctionIdentifier(hoistedBinding: Binding): t.Identifier;
 export declare function getSignal(section: Section, referencedBindings: ReferencedBindings, name?: string): Signal;
 export declare function initValue(binding: Binding, isLet?: boolean): Signal;
+export declare function signalHasStatements(signal: Signal): boolean;
 export declare function getSignalFn(signal: Signal): t.Expression;
 export declare function subscribe(references: ReferencedBindings, subscriber: Signal): void;
 export declare function replaceNullishAndEmptyFunctionsWith0(args: (t.Expression | undefined | false)[]): t.Expression[];

package/dist/translator/util/walks.d.ts

@@ -9,7 +9,7 @@ type VisitCodes = WalkCode.Get | WalkCode.Inside | WalkCode.Replace | WalkCode.D
 export declare function enter(path: t.NodePath<any>): void;
 export declare function exit(path: t.NodePath<any>): void;
 export declare function enterShallow(path: t.NodePath<any>): void;
-export declare function injectWalks(tag: t.NodePath<t.MarkoTag>, expr: t.Expression): void;
+export declare function injectWalks(tag: t.NodePath<t.MarkoTag>, expr: t.Expression | undefined): void;
 export declare function visit(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder | t.Program>, code: VisitCodes): void;
 export declare function getWalkString(section: Section): t.Expression | undefined;
 export {};

package/dist/translator/util/writer.d.ts

@@ -6,9 +6,13 @@ export declare function writeTo(path: t.NodePath<any>, trailer?: boolean): (strs
 export declare function consumeHTML(path: t.NodePath<any>): t.ExpressionStatement | undefined;
 export declare function flushBefore(path: t.NodePath<any>): void;
 export declare function flushInto(path: t.NodePath<t.MarkoTag> | t.NodePath<t.Program>): void;
-export declare function getSectionMeta(section: Section): {
-    setup: t.Identifier | undefined;
+interface SectionMeta {
+    setup: t.Expression | undefined;
     walks: t.Expression | undefined;
     writes: t.Expression | undefined;
-};
+    decls: t.VariableDeclarator[] | undefined;
+}
+export declare const getSectionMeta: (section: Section) => SectionMeta;
+export declare function getSectionMetaIdentifiers(section: Section): SectionMeta;
 export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, nodeBinding: Binding, reason: undefined | false | SerializeReason): void;
+export {};

package/dist/translator/visitors/program/html.d.ts

@@ -1,9 +1,5 @@
 import { types as t } from "@marko/compiler";
-import type { SerializeReason, SerializeReasons } from "../../util/serialize-reasons";
 export declare function getTemplateContentName(): string;
-export declare function getSerializeGuard(reason: undefined | SerializeReason, optional: boolean): t.CallExpression | t.NumericLiteral | undefined;
-export declare function getSerializeGuardForAny(reasons: undefined | SerializeReasons, optional: boolean): t.Expression | undefined;
-export declare function getExprIfSerialized<T extends undefined | SerializeReason, U extends t.Expression>(reason: T, expr: U): T extends {} ? U : undefined;
 declare const _default: {
     translate: {
         exit(this: unknown, program: t.NodePath<t.Program>): void;

package/dist/translator/visitors/program/index.d.ts

@@ -1,31 +1,24 @@
 import { types as t } from "@marko/compiler";
-import { type Binding, type Sources } from "../../util/references";
-export type InputSerializeReason = NonNullable<Sources["input"]>;
-export type InputSerializeReasons = [
-    InputSerializeReason,
-    ...InputSerializeReason[]
+import { type BindingPropTree } from "../../util/binding-prop-tree";
+import { type Sources } from "../../util/references";
+import { type Section } from "../../util/sections";
+export type ParamSerializeReason = NonNullable<Sources["param"]>;
+export type ParamSerializeReasonGroups = [
+    ParamSerializeReason,
+    ...ParamSerializeReason[]
 ];
 export declare let cleanIdentifier: t.Identifier;
 export declare let scopeIdentifier: t.Identifier;
 export declare function isScopeIdentifier(node: t.Node): node is t.Identifier;
-export type TemplateExport = {
-    id: string;
-    binding: Binding;
-    props: {
-        [prop: string]: TemplateExport;
-    } | undefined;
-};
-export type TemplateExports = TemplateExport["props"];
+export type TemplateExports = BindingPropTree["props"];
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        inputSerializeReasons?: InputSerializeReasons;
-        returnSerializeReason?: InputSerializeReason | true;
         returnValueExpr?: t.NodeExtra;
         domExports?: {
             template: string;
             walks: string;
             setup: string;
-            input: TemplateExport | undefined;
+            params: BindingPropTree | undefined;
         };
     }
 }
@@ -44,4 +37,4 @@ declare const _default: {
     };
 };
 export default _default;
-export declare function resolveSerializeReasonId(inputSerializeReasons: InputSerializeReasons, reason: InputSerializeReason): number;
+export declare function resolveSerializeReasonId(paramReasonGroups: NonNullable<Section["paramReasonGroups"]>, reason: ParamSerializeReason): number;

package/dist/translator/visitors/tag/custom-tag.d.ts

@@ -1,15 +1,4 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "../../util/references";
-declare const kChildScopeBinding: unique symbol;
-declare const kChildOffsetScopeBinding: unique symbol;
-declare const kChildInputSerializePropIds: unique symbol;
-declare module "@marko/compiler/dist/types" {
-    interface MarkoTagExtra {
-        [kChildScopeBinding]?: Binding;
-        [kChildOffsetScopeBinding]?: Binding;
-        [kChildInputSerializePropIds]?: [symbol, ...symbol[]];
-    }
-}
 declare const _default: {
     analyze: {
         enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
@@ -21,4 +10,3 @@ declare const _default: {
 };
 export default _default;
 export declare function getTagRelativePath(tag: t.NodePath<t.MarkoTag>): string;
-export declare function getChildScopeBinding(path: t.NodePath<t.MarkoTag>): Binding;

package/dist/translator/visitors/tag/dynamic-tag.d.ts

@@ -1,11 +1,13 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
+import { type Section } from "../../util/sections";
 declare const kDOMBinding: unique symbol;
 declare const kChildOffsetScopeBinding: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
         [kDOMBinding]?: Binding;
         [kChildOffsetScopeBinding]?: Binding;
+        defineBodySection?: Section;
     }
 }
 declare const _default: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.79",
+  "version": "6.0.80",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",