marko 6.0.79 → 6.0.81

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/entry-builder.d.ts

@@ -3,7 +3,6 @@ declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         needsCompat?: boolean;
         isInteractive?: boolean;
-        hasInteractiveChild?: boolean;
     }
 }
 type EntryFile = t.BabelFile & {

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/is-event-or-change-handler.d.ts

@@ -0,0 +1 @@
+export declare function isEventOrChangeHandler(prop: string): boolean;

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

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { type Many, type Opt, Sorted } from "./optional";
 import { type Section } from "./sections";
+import { type SerializeReason } from "./serialize-reasons";
 declare const kIsInvoked: unique symbol;
 export declare const kBranchSerializeReason: unique symbol;
 export type Aliases = undefined | Binding | {
@@ -17,7 +18,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 +44,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 +91,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>;
@@ -116,12 +120,13 @@ export interface AssignedBindingExtra extends ReferencedExtra {
 export declare function isAssignedBindingExtra(extra: t.NodeExtra | undefined): extra is AssignedBindingExtra;
 export interface RegisteredFnExtra extends ReferencedExtra {
     registerId: string;
+    registerReason: SerializeReason;
     name: string;
     referencesScope?: boolean;
     referencedBindingsInFunction: ReferencedBindings;
 }
 export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): extra is RegisteredFnExtra;
 export declare function getCanonicalExtra<T extends t.NodeExtra>(extra: T): T;
-export declare function couldSerializeExtra(extra: t.NodeExtra): boolean;
-export declare function couldSerializeBinding(binding: Binding): boolean;
+export declare function getAllSerializeReasonsForExtra(extra: t.NodeExtra): undefined | SerializeReason;
+export declare function getAllSerializeReasonsForBinding(binding: Binding): undefined | SerializeReason;
 export {};

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

@@ -1,8 +1,9 @@
 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 SerializeReason } from "./serialize-reasons";
+import { type Binding, type InputBinding, type ParamBinding, type ReferencedBindings } from "./references";
+import type { SerializeReason } from "./serialize-reasons";
 export declare enum ContentType {
     Comment = 0,
     Dynamic = 1,
@@ -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,9 +29,11 @@ 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;
+    downstreamBinding: Binding | undefined | false;
     hasAbortSignal: boolean;
     isBranch: boolean;
     content: null | {
@@ -59,7 +62,7 @@ export declare const getScopeIdentifier: (section: Section, ignoreDefault?: bool
 export declare function forEachSection(fn: (section: Section) => void): void;
 export declare function forEachSectionReverse(fn: (section: Section) => void): void;
 export declare function getNodeContentType(path: t.NodePath<t.Statement>, extraMember: "startType" | "endType", contentInfo?: Section["content"]): ContentType | null;
-export declare const isSerializedSection: (section: Section) => boolean;
+export declare function getSectionRegisterReasons(section: Section): false | SerializeReason | undefined;
 export declare function isSectionWithHoists(section: Section): boolean;
 export declare function isImmediateOwner(section: Section, binding: Binding): boolean;
 export declare function isDirectClosure(section: Section, closure: Binding): boolean;

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,32 +1,27 @@
 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;
 export type SerializeKey = symbol & {
     __serialize_key__: 1;
 };
-export declare function forceOwnersSerialize(from: Section, to: Section, prop?: AccessorProp | symbol): void;
-export declare function addOwnersSerializeReason(from: Section, to: Section, reason: undefined | boolean | SerializeReason, prop?: AccessorProp | symbol): void;
-export declare function forceSectionSerialize(section: Section, prop?: AccessorProp | symbol): void;
-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 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;
-export declare function addBindingSerializeReasonRef(section: Section, binding: Binding, ref: undefined | boolean | ReferencedBindings, prefix?: AccessorPrefix | symbol): void;
-export declare function addSectionSerializeReason(section: Section, reason: undefined | false | SerializeReason, prop?: AccessorProp | symbol): void;
-export declare function addBindingSerializeReason(section: Section, binding: Binding, reason: undefined | false | SerializeReason, prefix?: AccessorPrefix | symbol): void;
-export declare function getSectionSerializeReason(section: Section, prop?: AccessorProp | symbol): SerializeReason | undefined;
-export declare function getBindingSerializeReason(section: Section, binding: Binding, prefix?: AccessorPrefix | symbol): SerializeReason | undefined;
-export declare function applySerializeReasonExprs(section: Section): void;
-export declare function finalizeSectionSerializeReasons(section: Section): void;
+export declare function isForceSerialized(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): boolean;
+export declare function addSerializeReason(section: Section, reason: undefined | false | SerializeReason, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;
+export declare function addSerializeExpr(section: Section, expr: boolean | Opt<t.NodeExtra>, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;
+export declare function addOwnerSerializeReason(from: Section, to: Section, reason: undefined | boolean | SerializeReason): void;
+export declare function isReasonDynamic(reason: undefined | SerializeReason): reason is {
+    state: undefined;
+    param: OneMany<InputBinding | ParamBinding>;
+};
+export declare function getSerializeReason(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): SerializeReason | undefined;
 export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): Sources | undefined;
 export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra>): Sources | undefined;
 export declare function getSerializeSourcesForRef(ref: ReferencedBindings): Sources | undefined;
 export declare function mergeSerializeReasons(a: SerializeReason, b: undefined | SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: undefined | SerializeReason): SerializeReason | undefined;
+export declare function applySerializeExprs(section: Section): void;
+export declare function finalizeSerializeReason(section: Section): void;

package/dist/translator/util/set-tag-sections-downstream.d.ts

@@ -0,0 +1,4 @@
+import { types as t } from "@marko/compiler";
+import type { Binding } from "./references";
+export declare function setTagDownstream(tag: t.NodePath<t.MarkoTag>, binding: undefined | false | Binding): void;
+export declare function finalizeTagDownstreams(): 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/function.d.ts

@@ -1,15 +1,19 @@
 import { types as t } from "@marko/compiler";
+import { type SerializeReason } from "../util/serialize-reasons";
 declare module "@marko/compiler/dist/types" {
     interface FunctionDeclarationExtra {
         registerId?: string;
+        registerReason?: SerializeReason;
         name?: string;
     }
     interface FunctionExpressionExtra {
         registerId?: string;
+        registerReason?: SerializeReason;
         name?: string;
     }
     interface ArrowFunctionExpressionExtra {
         registerId?: string;
+        registerReason?: SerializeReason;
         name?: string;
     }
 }

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.81",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -48,7 +48,7 @@
     "build": "node -r ~ts ./scripts/bundle.ts"
   },
   "dependencies": {
-    "@marko/compiler": "^5.39.39",
+    "@marko/compiler": "^5.39.40",
     "csstype": "^3.1.3",
     "magic-string": "^0.30.17"
   },

package/tags/debug.d.marko

@@ -1,5 +1,5 @@
 /** File for types only, not actual implementation **/
 
 export interface Input {
-  value?: unknown;
+  value?: any;
 }

package/tags/log.d.marko

@@ -1,5 +1,5 @@
 /** File for types only, not actual implementation **/
 
 export interface Input {
-  value: unknown;
+  value: any;
 }

package/tags/do.d.marko

@@ -1,5 +0,0 @@
-/** File for types only, not actual implementation **/
-
-export interface Input {
-  value?(): unknown;
-}