marko 6.3.52 → 6.3.54

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

@@ -3,3 +3,4 @@ import type { Binding } from "./references";
 import type { Section } from "./sections";
 export declare function isSectionRendererElided(section: Section): boolean;
 export declare function bindingHasProperty(binding: Binding, properties: Opt<string>): boolean;
+export declare function getPropertyPathAlias(binding: Binding, properties: Opt<string>): Binding;

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

@@ -1,5 +1,10 @@
+import { types as t } from "@marko/compiler";
 import { type Binding } from "./references";
-import type { Section } from "./sections";
+import { type Section } from "./sections";
+import { type SerializeReason, type SerializeReasons } from "./serialize-reasons";
 export declare function getBranchSectionAccessor(nodeBinding: Binding): NonNullable<Section["sectionAccessor"]>;
 export declare function initBranchSection(bodySection: Section, upstreamExpression: Section["upstreamExpression"], sectionAccessor: Section["sectionAccessor"]): void;
 export declare function resumeOwnerByMarkerWhenStatic(tagSection: Section, bodySection: Section, nodeBinding: Binding, statefulReasonKey: symbol): void;
+export declare function getBranchResumeArgs(tag: t.NodePath<t.MarkoTag>, tagSection: Section, nodeBinding: Binding, branchReasons: SerializeReasons, statefulReasonKey: symbol, onlyChildParentTagName: string | false | undefined, singleNode: boolean): (t.Expression | undefined)[];
+export declare function getBranchEndArgs(tag: t.NodePath<t.MarkoTag>, tagSection: Section, nodeBinding: Binding, statefulReason: SerializeReason | undefined, onlyChildParentTagName: string | false | undefined, singleNode: boolean | undefined): (t.Expression | undefined)[];
+export declare function isSingleNodeBranch(bodySection: Section | undefined): boolean;

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

@@ -18,6 +18,8 @@ export declare class Sorted<T> {
     has<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): boolean;
     findIndex<U extends NonNullable<T>>(data: SortedOpt<U>, item: U): number;
     groupBy<U extends NonNullable<T>, K>(data: SortedOpt<U>, cb: (item: U) => K): Map<K, SortedOneMany<U>>;
+    intersects<U extends NonNullable<T>>(a: SortedOpt<U>, b: SortedOpt<U>): boolean;
+    difference<U extends NonNullable<T>>(a: SortedOpt<U>, b: SortedOpt<U>): SortedOpt<U>;
     isSuperset<U extends NonNullable<T>>(superset: SortedOpt<U>, subset: SortedOpt<U>): boolean;
 }
 export declare function push<T>(data: Opt<T>, item: T): OneMany<T>;

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

@@ -1,5 +1,5 @@
 import { types as t } from "@marko/compiler";
-import type { AccessorPrefix } from "../../common/accessor.debug";
+import { type AccessorPrefix } from "../../common/accessor.debug";
 import * as BindingType from "./constants/binding-type";
 import { type Many, type Opt, type SortedMany, type SortedOpt, Sorted } from "./optional";
 import { type Section } from "./sections";
@@ -43,14 +43,25 @@ export interface Binding {
     property: string | undefined;
     propertyAliases: Map<string, Binding>;
     excludeProperties: SortedOpt<string>;
-    noSerialize: boolean;
-    noSerializeProperties: SortedOpt<string>;
     upstreamAlias: Binding | undefined;
+    /** The value these `<for>` params iterate, by `of` or `in`. */
+    iterates: {
+        expr: t.NodeExtra;
+        type: "of" | "in";
+    } | undefined;
     restOffset: number | undefined;
     scopeOffset: Binding | undefined;
     scopeAccessor: string | undefined;
     export: string | undefined;
     directContentExport: string | undefined;
+    /** A name declared for this value, or all of it but its `excludeProperties`
+     * (a rest element), even once pruned. */
+    declaredAlias: Binding | undefined;
+    /** The attribute tag `<for>` param a local closure holds in its section. */
+    upstreamLocal: Binding | undefined;
+    /** An attribute tag `<for>` param's local closure in each content the loop
+     * creates that reads it. */
+    localClosures: Map<Section, Binding> | undefined;
     declared: boolean;
     nullable: boolean;
     pruned: boolean | undefined;
@@ -94,7 +105,8 @@ interface ExtraRead {
 }
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        /** This template reads `$global`, so HTML output declares a const for it. */
+        /** The template emits a `$global` read, so HTML output declares a const
+         * for it. */
         hasGlobalRead?: true;
     }
     interface NodeExtra {
@@ -104,6 +116,9 @@ declare module "@marko/compiler/dist/types" {
         nodeBinding?: Binding;
         referencedBindings?: ReferencedBindings;
         downstream?: SortedOpt<Binding>;
+        /** The initial value of the binding it feeds, which keeps it rather than
+         * following it, so the binding derives no sources from it. */
+        initialValue?: true;
         /** The tag-root `KnownExprs` of the call site that linked this expression
          * to a downstream template's binding, for dereferencing its reasons. */
         downstreamExprs?: KnownExprs;
@@ -115,16 +130,17 @@ declare module "@marko/compiler/dist/types" {
         /** The expression this node sits in: dropped or merged as one. */
         exprRoot?: NodeExtra;
         isEffect?: true;
-        /** The expression is a dynamic tag's input (attrs, args, attr tags). */
-        dynamicTagInput?: true;
+        /** A value here may reach the client as written (a change handler, a
+         * native spread, a dynamic tag's input), so a function in it registers. */
+        forceRegister?: true;
         invokeOnly?: true;
         lazyBindings?: ReferencedBindings;
         /** `$global` bindings this expression reads: the root means an opaque
          * (dynamic/aliased) read, a property alias names the key. */
         globalBindings?: ReferencedBindings;
-        spreadFrom?: Binding;
+        /** The bindings this expression reads only by spreading them as is. */
+        spreadFrom?: SortedOpt<Binding>;
         nativeTagSpread?: true;
-        nativeTagSpreadMerged?: true;
         merged?: NodeExtra;
     }
     interface FunctionExtra {
@@ -157,7 +173,6 @@ export declare function trackGlobalReference(path: t.NodePath<t.Identifier>): vo
 export declare function mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]> & ReferencedExtra;
 export declare function compareReferences(a: ReferencedBindings, b: ReferencedBindings): number;
 export declare function finalizeReferences(): void;
-export declare function dropReferencedBindings(expr: ReferencedExtra, drop: ReferencedBindings): boolean;
 /**
  * Every member computed from one local source in the same pass, or the
  * intersection's own render id and scope offset.
@@ -173,7 +188,6 @@ type IntersectionMeta = {
 };
 export declare const intersectionMeta: WeakMap<Intersection, IntersectionMeta>;
 export declare function setBindingDownstream(binding: Binding, expr: boolean | Opt<t.NodeExtra>, exprs?: KnownExprs): void;
-export declare function setBindingValueExprs(binding: Binding, expr: boolean | Opt<t.NodeExtra>): void;
 export declare function createSources(state: Sources["state"], param: Sources["param"], global?: Sources["global"], forced?: Sources["forced"]): Sources;
 export declare function compareSources(a: Sources, b: Sources): number;
 export declare function mergeSources(a: undefined | Sources, b: undefined | Sources): Sources | undefined;
@@ -186,9 +200,9 @@ export declare function dropNodes(node: t.Node | t.Node[]): void;
 export declare function untrackNode(node: t.Node): void;
 export declare function getCanonicalBinding(binding: Binding): Binding;
 export declare function someAlias<A>(binding: Binding, test: (binding: Binding, arg: A) => boolean, arg: A, directOnly?: boolean): boolean;
-export declare function someUpstream<A>(binding: Binding, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
+export declare function someUpstream<A>(binding: Binding | undefined, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
 export declare function isDirectAlias(binding: Binding): boolean;
-export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[]): t.Node[];
+export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[], getAttrTagNodes?: (attrTag: t.MarkoTag) => t.Node[]): t.Node[];
 export declare function getScopeAccessorLiteral(binding: Binding, encoded?: boolean, includeId?: boolean): t.NumericLiteral | t.StringLiteral;
 export declare function getScopeAccessor(binding: Binding, encoded?: boolean, includeId?: boolean): string;
 export declare function getLocalsScopeAccessor(binding: Binding): string;

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

@@ -6,7 +6,8 @@ export type HTMLRuntimeHelpers = keyof typeof import("../../html");
 export declare function importRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers): t.Identifier;
 export declare function registerRuntimeValue(id: string, value: t.Expression): t.AssignmentExpression;
 export declare function callRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers, ...args: Array<Parameters<typeof t.callExpression>[1][number] | Falsy>): t.CallExpression;
-export declare const domRuntimeFeatures: readonly ["catch", "controllable", "controllable-input", "controllable-open", "controllable-select", "controllable-textarea", "dynamic-tag-var", "placeholder"];
+export declare function dynamicImport(request: string, ...handlers: Array<t.Expression | Falsy>): t.CallExpression;
+export declare const domRuntimeFeatures: readonly ["catch", "controllable", "controllable-input", "controllable-open", "controllable-select", "controllable-textarea", "dynamic-tag-script", "dynamic-tag-var", "placeholder"];
 export type DOMRuntimeFeature = (typeof domRuntimeFeatures)[number];
 export declare function importRuntimeFeature(feature: DOMRuntimeFeature): void;
 export declare function getHTMLRuntime(): {

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

@@ -4,7 +4,7 @@ import type { WalkCode } from "../../common/types";
 import * as ContentType from "./constants/content-type";
 import type * as Step from "./constants/step";
 import * as StructureKind from "./constants/structure-kind";
-import { type OneMany, type Opt, Sorted } from "./optional";
+import { type OneMany, type Opt, Sorted, type SortedOpt } from "./optional";
 import { type Binding, type InputBinding, type KnownExprs, type ParamBinding, type ReferencedBindings, type Sources } from "./references";
 import { type SerializeKey, type SerializeReason, type SerializeReasons } from "./serialize-reasons";
 export interface ParamSerializeReasonGroup {
@@ -56,7 +56,9 @@ export interface Section {
         prefix: AccessorPrefix;
     } | undefined;
     params: undefined | ParamBinding | InputBinding;
-    referencedLocalClosures: ReferencedBindings;
+    /** The attribute tag `<for>` params this content reads, held as its own
+     * bindings that the loop binds as it creates it. */
+    localClosures: ReferencedBindings;
     referencedClosures: ReferencedBindings;
     referencedHoists: ReferencedBindings;
     bindings: ReferencedBindings;
@@ -78,11 +80,13 @@ export interface Section {
     returnSerializeReason: SerializeReason | undefined;
     isHoistThrough: true | undefined;
     upstreamExpression: t.NodeExtra | undefined;
+    /** For a `<define>` body, the sections whose direct calls render it. */
+    callSections: SortedOpt<Section>;
     /** The content's rendering tag (its extra), and each child binding the
-     * content feeds when the child can serialize it. */
+     * content feeds, at `properties`. */
     downstream: {
         tag: t.MarkoTagExtra;
-        binding: Opt<Binding>;
+        binding: OneMany<Binding>;
         properties: Opt<string>;
         exprs: KnownExprs | undefined;
     } | undefined;
@@ -118,17 +122,16 @@ export declare const getSectionParentIsOwner: (section: Section) => boolean, set
 export declare const getBranchRendererArgs: (section: Section) => [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined], setBranchRendererArgs: (section: Section, value: [template?: t.Expression | undefined, walks?: t.Expression | undefined, setup?: t.Expression | undefined, params?: t.Expression | undefined]) => void;
 export declare function forEachSection(fn: (section: Section) => void): void;
 export declare function getChildSections(section: Section): Section[];
-export declare function ancestorSections(from: Section, to: Section): Generator<Section, void, unknown>;
+export declare function getContentClosures(section: Section): ReferencedBindings;
+export declare function forEachAncestorSection<A>(from: Section, to: Section, fn: (section: Section, arg: A) => void, arg: A): 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.Value | null;
 export declare function getSectionRegisterReasons(section: Section): boolean | Sources;
-export declare function isSectionRegisterDynamic(section: Section, registerReason: true | SerializeReason): boolean;
-export declare function isSectionRegisterEager(section: Section): boolean;
 export declare function isImmediateOwner(section: Section, binding: Binding): boolean;
 export declare function isDirectClosure(section: Section, closure: Binding): boolean;
 export declare function isDynamicClosure(section: Section, closure: Binding): boolean;
 export declare function getDynamicClosureIndex(closure: Binding, closureSection: Section): number;
-export declare function getDirectClosures(section: Section): import("./optional").SortedOpt<Binding>;
+export declare function getDirectClosures(section: Section): SortedOpt<Binding>;
 export declare function isSameOrChildSection(section: Section, other: Section): boolean;
 export declare function getCommonSection(section: Section, other: Section): Section;
 export declare function finalizeParamSerializeReasonGroups(section: Section): void;

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

@@ -1,17 +1,11 @@
 import { types as t } from "@marko/compiler";
-import { type Sources } from "./references";
 import { type Section } from "./sections";
 import { type SerializeReason, type SerializeReasons } from "./serialize-reasons";
-type DynamicSerializeReason = Sources & {
-    state: undefined;
-};
 export declare function buildGroupMask(groups: {
     value: number | t.Expression | undefined;
     names: string;
 }[]): t.Expression | undefined;
-export declare function getScopeReasonDeclaration(section: Section): t.VariableDeclaration;
+export declare function getScopeReasonStatement(section: Section): t.Statement;
 export declare function getSerializeGuard(section: Section, reason: undefined | SerializeReason, optional: boolean): t.Expression | undefined;
 export declare function getSerializeGuardForAny(section: Section, reasons: undefined | SerializeReasons, optional: boolean): t.Expression | undefined;
 export declare function getExprIfSerialized<T extends undefined | SerializeReason, R extends (T extends {} ? t.Expression : undefined)>(section: Section, reason: T, expr: t.Expression): R;
-export declare function isDynamicSerializeGuard(section: Section, reason: undefined | SerializeReason): reason is DynamicSerializeReason;
-export {};

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

@@ -20,13 +20,16 @@ export declare function isReasonDynamic(reason: undefined | SerializeReason): re
 };
 export declare function isStaticSerializeReason(reason: undefined | SerializeReason): reason is SerializeReason;
 export declare function isStateSerializeReason(reason: undefined | SerializeReason): reason is Sources;
+export declare function hasSerializeReasons(section: Section | undefined): boolean;
 export declare function getSerializeReason(section: Section, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): Sources | undefined;
 export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): Sources | undefined;
 export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): Sources | undefined;
 export declare function getSerializeSourcesForRef(ref: ReferencedBindings): Sources | undefined;
+export declare function getSerializeSourcesForDownstream({ binding, exprs, properties, }: NonNullable<Section["downstream"]>): Sources | undefined;
 export declare function mapParamReason(program: Section, reason: Sources, exprs: KnownExprs | undefined, ownParams: boolean): SerializeReason | 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;
+export declare function getSerializeReasonsVersion(): number;

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

@@ -1,6 +1,6 @@
 import { types as t } from "@marko/compiler";
 import { type Opt } from "./optional";
-import { type Binding, type KnownExprs } from "./references";
+import type { Binding, KnownExprs } from "./references";
 import { type Section } from "./sections";
 export declare function setTagDownstream(tag: t.NodePath<t.MarkoTag>, binding: Opt<Binding>, exprs?: KnownExprs): void;
 export declare function finalizeTagDownstreams(section: Section): void;

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

@@ -37,8 +37,11 @@ export interface Signal {
 type closureSignalBuilder = (closure: Binding, render: t.Expression) => t.Expression;
 export declare const getSignals: (section: Section) => Map<unknown, Signal>;
 export declare function setClosureSignalBuilder(tag: t.NodePath<t.MarkoTag>, builder: closureSignalBuilder): void;
-export declare const getTryHasPlaceholder: (section: Section) => true | undefined, setTryHasPlaceholder: (section: Section, value: true | undefined) => void;
 export declare function setSectionOwnerResumedByMarker(section: Section): void;
+export declare function getContentClosureValues(bodySection: Section): {
+    scope: t.Identifier;
+    levels: t.Expression[];
+} | undefined;
 export declare function setSectionSerializedValue(section: Section, prop: AccessorProp, expression: t.Expression): void;
 export declare function setBindingSerializedValue(section: Section, binding: Binding, expression: t.Expression, prefix?: AccessorPrefix): void;
 export declare function setSectionDebugVar(section: Section, accessor: string, name: string, loc: t.SourceLocation | null | undefined): void;

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

@@ -19,9 +19,9 @@ export declare function resolveStructure(section: Section): ResolvedStructure;
 interface SectionMeta {
     walks: t.Expression | undefined;
     writes: t.Expression | undefined;
-    decls: t.VariableDeclarator[] | undefined;
 }
 export declare const getSectionMeta: (section: Section) => SectionMeta;
+export declare function writeStructureExports(program: t.NodePath<t.Program>): void;
 export declare function getSectionMetaIdentifiers(section: Section): SectionMeta;
 /** `_content` strips trailing exit codes before it walks, so a renderer that
  * reaches the runtime through it never needs them on the wire. */

package/dist/translator/util/tag-name-type.d.ts

@@ -1,5 +1,5 @@
 import { types as t } from "@marko/compiler";
-import type { LoadImportConfig } from "../visitors/import-declaration";
+import { type LoadImportConfig } from "../visitors/import-declaration";
 import * as TagNameType from "./constants/tag-name-type";
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {

package/dist/translator/visitors/function.d.ts

@@ -17,6 +17,7 @@ declare const _default: {
     analyze(this: unknown, fn: t.NodePath<t.Function>): void;
 };
 export default _default;
+export declare function resolveFunctionRegisterReasons(): void;
 export declare function finalizeFunctionRegistry(): void;
 /**
  * Tracks a function imported from another template that reserved a register id.

package/dist/translator/visitors/import-declaration.d.ts

@@ -28,3 +28,4 @@ declare const _default: {
     };
 };
 export default _default;
+export declare function getImportFacts(importDecl: t.NodePath<t.ImportDeclaration>): t.NodeExtra;

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

@@ -17,4 +17,9 @@ declare const _default: {
 };
 export default _default;
 export declare function getTagRelativePath(tag: t.NodePath<t.MarkoTag>): string;
+/**
+ * A known wrong tag that resolves to nothing, eg `interface P { id: number }`,
+ * whose body lands in attribute position before tag resolution would run.
+ */
+export declare function isUnresolvedKnownWrongTag(tag: t.NodePath<t.MarkoTag>): boolean;
 export declare function tagNotFoundError(tag: t.NodePath<t.MarkoTag>): Error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.3.52",
+  "version": "6.3.54",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,14 +51,14 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.5",
+    "@marko/compiler": "^5.42.7",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.3.52",
-    "marko": "5.39.41"
+    "@marko/runtime-tags": "npm:marko@6.3.54",
+    "marko": "5.39.43"
   },
   "engines": {
     "node": ">=22"

package/tags/try.d.marko

@@ -3,5 +3,7 @@
 export interface Input {
   content: Marko.Body,
   placeholder?: Marko.AttrTag<{ content?: Marko.Body }>,
+  // `any` keeps the documented `${err.message}` working; annotating the
+  // parameter as `|err: unknown|` opts a catch into narrowing.
   catch?: Marko.AttrTag<{ content?: Marko.Body<[any]> }>,
 }

package/tags-html.d.ts

@@ -94,6 +94,7 @@ declare global {
       s: NativeTag<Marko.HTML.S, HTMLElement>;
       samp: NativeTag<Marko.HTML.Samp, HTMLElement>;
       script: NativeTag<Marko.HTML.Script, HTMLScriptElement>;
+      search: NativeTag<Marko.HTML.Search, HTMLElement>;
       section: NativeTag<Marko.HTML.Section, HTMLElement>;
       select: NativeTag<Marko.HTML.Select, HTMLSelectElement>;
       slot: NativeTag<Marko.HTML.Slot, HTMLSlotElement>;
@@ -1986,6 +1987,7 @@ declare global {
         language?: AttrString;
       }
 
+      interface Search extends HTMLAttributes<HTMLElement> {}
       interface Section extends HTMLAttributes<HTMLElement> {}
       interface Select extends HTMLAttributes<HTMLSelectElement> {
         /**
@@ -4406,6 +4408,8 @@ declare global {
 
       /**
        * Provide body content for the tag as a Marko.Body.
+       * Native tags render it without params; a component whose body receives values
+       * should `Omit<Marko.HTML.Div, "content">` and declare its own `content`.
        * @see Marko.Body
        */
       content?:
@@ -4457,6 +4461,8 @@ declare global {
 
       /**
        * Provide body content for the tag as a Marko.Body.
+       * Native tags render it without params; a component whose body receives values
+       * should `Omit<Marko.SVG.Path, "content">` and declare its own `content`.
        * @see Marko.Body
        */
       content?: