marko 6.4.0 → 6.4.2

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

@@ -0,0 +1,21 @@
+import { type Binding, type ParamBinding } from "./bindings";
+import { type SortedOpt } from "./optional";
+export interface Sources {
+    state: SortedOpt<Binding>;
+    param: SortedOpt<ParamBinding>;
+    global: true | undefined;
+    /** Read whatever changes, as an effect or handler reads on resume; the
+     * other fields still say what it reads. */
+    always: true | undefined;
+}
+export declare const ALWAYS: Sources;
+export declare const globalSources: Sources;
+export declare function sharesSources(a: Binding, b: Binding): boolean;
+export declare function createSources(state: Sources["state"], param: Sources["param"], global?: Sources["global"], always?: Sources["always"]): Sources;
+export declare function withSources(sources: Sources, state: Sources["state"], param: Sources["param"]): Sources | undefined;
+export declare function compareSources(a: Sources, b: Sources): number;
+export declare function mergeSources(a: Sources, b: undefined | Sources): Sources;
+export declare function mergeSources(a: undefined | Sources, b: Sources): Sources;
+export declare function mergeSources(a: undefined | Sources, b: undefined | Sources): Sources | undefined;
+export declare function isInParams(binding: Binding, params: Sources["param"]): boolean;
+export declare function isSupersetSources(a: Binding, b: Binding): boolean;

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

@@ -1,13 +1,17 @@
 import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
 import * as Step from "./constants/step";
-import { type Section, type StructureRef, type StructureVisit } from "./sections";
+import { type Section, type StructureNode, type StructureRef } from "./sections";
 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 child(tag: t.NodePath<t.MarkoTag>, name: string, renderer?: StructureRef): void;
 export declare function writeTo(path: t.NodePath<any>): (strs: TemplateStringsArray, ...exprs: string[]) => void;
+export declare function writeModuleReadTo(path: t.NodePath<any>, read: string[]): void;
 export declare function writeTextTo(path: t.NodePath<any>, value: string): void;
-export declare function visit(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder | t.Program>, code: StructureVisit["code"], claimed?: boolean): StructureVisit | undefined;
+export declare function node(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, binding?: Binding): StructureNode | undefined;
+export declare function marker(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, binding: Binding): void;
+export declare function controlFlowNode(tag: t.NodePath<t.MarkoTag>, section: Section): Binding;
 type ResolvedPart = string | t.Expression;
 interface ResolvedStructure {
     writes: ResolvedPart[];

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

@@ -0,0 +1,21 @@
+import { types as t } from "@marko/compiler";
+import * as ContentType from "./constants/content-type";
+export interface TagFacts {
+    /** What renders at its edges, `null` for nothing. */
+    content: ContentType.Value | null | ((tag: t.MarkoTag) => ContentType.Value | null);
+    /** Its body renders into the section holding the tag. */
+    inlineBody?: true;
+    /** Its body is text rather than markup. */
+    textBody?: true;
+    /** It renders its body in its own place, with no node of its own. */
+    controlFlow?: true;
+    /** One of the document's own elements: the parser implies and moves nodes
+     * into it, and the page writes assets and resume scripts into it. */
+    pageElement?: true;
+    /** Its insertion mode drops an unknown element but keeps its children, so a
+     * wrapper around content inside it is discarded. */
+    discardsWrapperChildren?: true;
+}
+export declare function getTagFacts(tag: t.NodePath<t.MarkoTag>): TagFacts;
+export declare function getTagContentType(tag: t.NodePath<t.MarkoTag>): ContentType.Value | null;
+export declare function isNonHTMLText(child: t.NodePath<t.MarkoPlaceholder | t.MarkoText>): boolean;

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

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { type LoadImportConfig } from "../visitors/import-declaration";
 import * as TagNameType from "./constants/tag-name-type";
+declare const kTagNameDynamic: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         featureType?: "class" | "tags";
@@ -9,6 +10,8 @@ declare module "@marko/compiler/dist/types" {
     }
     interface NodeExtra {
         tagNameType?: TagNameType;
+    }
+    interface MarkoTagExtra {
         tagNameNullable?: boolean;
         tagNameImported?: string;
         /** Every template the name may resolve to, when it can resolve to
@@ -17,7 +20,7 @@ declare module "@marko/compiler/dist/types" {
         tagNameLoad?: LoadImportConfig;
     }
     interface MarkoTagExtra {
-        tagNameDynamic?: boolean;
+        [kTagNameDynamic]?: boolean;
         tagNameUnresolved?: boolean;
         featureType?: ProgramExtra["featureType"];
     }

package/dist/translator/util/translate-attrs.d.ts

@@ -1,5 +1,6 @@
 import { types as t } from "@marko/compiler";
 import { type BindingPropTree } from "./binding-prop-tree";
+import { type Binding } from "./bindings";
 import { type AttrTagLookup } from "./nested-attribute-tags";
 import { type SortedOpt } from "./optional";
 type ContentKey = "renderBody" | "content";
@@ -14,4 +15,5 @@ export declare function addDynamicAttrTagStatements(attrTags: t.NodePath<t.Marko
 /** Unwraps a lone spread to the spread argument itself, so the result may alias
  * a caller binding; anything the runtime writes to needs its own object. */
 export declare function propsToExpression(props: t.ObjectExpression["properties"]): t.Expression;
+export declare function getSingleKnownSpread(attributes: (t.MarkoAttribute | t.MarkoSpreadAttribute)[]): Binding | undefined;
 export {};

package/dist/translator/util/translate-var.d.ts

@@ -1,2 +1,5 @@
 import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
 export default function translateVar(tag: t.NodePath<t.MarkoTag>, initialValue: t.Expression, kind?: "let" | "const", statements?: t.Statement[]): void;
+export declare function getRestPattern(rest: Binding, id: t.Identifier, from: Binding, shorthand: boolean): t.ArrayPattern | t.ObjectPattern;
+export declare function withRestFallback(rest: Binding, from: Binding, value: t.Expression): t.Expression;

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

@@ -0,0 +1,12 @@
+import { types as t } from "@marko/compiler";
+import { type Reason, type Reasons } from "./reasons";
+import { type Section } from "./sections";
+export declare function isSameReason(a: Reason | undefined, b: Reason | undefined): boolean;
+export declare function buildGroupMask(groups: {
+    value: number | t.Expression | undefined;
+    names: string;
+}[]): t.Expression | undefined;
+export declare function getScopeReasonStatement(section: Section): t.Statement;
+export declare function getWriteGuard(section: Section, reason: undefined | Reason, optional: boolean): t.Expression | undefined;
+export declare function getWriteGuardForAny(section: Section, reasons: undefined | Reasons, optional: boolean): t.Expression | undefined;
+export declare function getExprIfWritten<T extends undefined | Reason, R extends (T extends {} ? t.Expression : undefined)>(section: Section, reason: T, expr: t.Expression): R;

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

@@ -1,10 +1,10 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "./references";
-import type { SerializeReason } from "./serialize-reasons";
+import { type Binding } from "./bindings";
+import type { Reason } from "./reasons";
 type Write = string | t.Expression | (() => undefined | string | t.Expression);
 export declare function writeTo(path: t.NodePath<any>, trailer?: boolean): (strs: TemplateStringsArray, ...exprs: Write[]) => void;
 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 markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, nodeBinding: Binding, reason: undefined | false | SerializeReason, deferred?: boolean): void;
+export declare function markNode(path: t.NodePath<t.MarkoTag | t.MarkoPlaceholder>, nodeBinding: Binding, reason: undefined | false | Reason, deferred?: boolean): void;
 export {};

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

@@ -1,4 +1,13 @@
 import { types as t } from "@marko/compiler";
+declare const kTagImport: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface ExportNamedDeclarationExtra {
+        [kTagImport]?: string;
+    }
+    interface ExportAllDeclarationExtra {
+        [kTagImport]?: string;
+    }
+}
 declare const _default: {
     analyze(this: unknown, exportDecl: t.NodePath<t.ExportAllDeclaration | t.ExportNamedDeclaration>): void;
     translate: {

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

@@ -1,7 +1,8 @@
 import { types as t } from "@marko/compiler";
+declare const kRegisteredExports: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        registeredExports?: Map<string, ReservedExport>;
+        [kRegisteredExports]?: Map<string, ReservedExport>;
     }
 }
 /** The canonical name a reserved register id is exported under, and its id. */
@@ -17,12 +18,12 @@ declare const _default: {
     analyze(this: unknown, fn: t.NodePath<t.Function>): void;
 };
 export default _default;
-export declare function resolveFunctionRegisterReasons(): void;
+export declare function resolveFunctionReason(): void;
 export declare function finalizeFunctionRegistry(): void;
 /**
  * Tracks a function imported from another template that reserved a register id.
- * The importing template registers it (under the reserved id) when its own
- * references reach something serialized.
+ * The importing template registers it (under the reserved id) when client
+ * code reads its own references.
  */
 export declare function trackImportedFn(importDecl: t.NodePath<t.ImportDeclaration>, local: string, resolved: ResolvedExport): void;
 /**

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

@@ -6,7 +6,7 @@ declare module "@marko/compiler/dist/types" {
         /** Absolute filenames of templates this one imports with `load`. */
         loadImports?: Set<string>;
     }
-    interface NodeExtra {
+    interface ImportDeclarationExtra {
         tagImport?: string;
         loadImport?: LoadImportConfig;
         registeredImportedFns?: (ResolvedExport & {
@@ -28,4 +28,4 @@ declare const _default: {
     };
 };
 export default _default;
-export declare function getImportFacts(importDecl: t.NodePath<t.ImportDeclaration>): t.NodeExtra;
+export declare function getImportFacts(importDecl: t.NodePath<t.ImportDeclaration>): t.ImportDeclarationExtra & t.NodeExtra;

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

@@ -1,12 +1,9 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "../util/references";
 import * as SiblingText from "./constants/sibling-text";
-declare const kNodeBinding: unique symbol;
 declare const kSiblingText: unique symbol;
 type SiblingText = SiblingText.Value;
 declare module "@marko/compiler/dist/types" {
     interface MarkoPlaceholderExtra {
-        [kNodeBinding]?: Binding;
         [kSiblingText]?: SiblingText;
     }
 }

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

@@ -1,17 +1,27 @@
 import { types as t } from "@marko/compiler";
 import { type BindingPropTree } from "../../util/binding-prop-tree";
+import { type Binding } from "../../util/bindings";
 import { preAnalyze } from "./pre-analyze";
 export declare let scopeIdentifier: t.Identifier;
 export declare let localsIdentifier: t.Identifier;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
+        /** Client code reads something of its own after resume (a section, or a
+         * renderer it registers), so a page bundles it. */
         hasResumes?: boolean;
-        domExports?: {
+        /** What the template reads of its params (its input is the first), the
+         * contract its callers keep. */
+        paramsTree?: BindingPropTree;
+        /** The names every compile of the template exports its parts under. */
+        exportNames?: {
             template: string;
             walks: string;
             setup: string;
-            setupEmpty?: true;
-            params: BindingPropTree | undefined;
+            /** The signal of each of the template's param bindings, a property of
+             * one included. */
+            params: Map<Binding, string>;
+            /** Each content passthrough's `_dynamic_tag_content` signal. */
+            directContent: Map<Binding, string>;
         };
         styleFile?: string;
     }

package/dist/translator/visitors/referenced-identifier.d.ts

@@ -1,9 +1,10 @@
 import { types as t } from "@marko/compiler";
+declare const kAbortId: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
         /** `$signal` abort id for this expression root, allocated in analyze
          * (see below) so every translate reads the same id. */
-        abortId?: number;
+        [kAbortId]?: number;
     }
 }
 declare const _default: {

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

@@ -1,5 +1,5 @@
 import { types as t } from "@marko/compiler";
-import type { Binding } from "../../util/references";
+import { type Binding } from "../../util/bindings";
 declare const kLoadTagBinding: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {

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

@@ -1,8 +1,6 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "../../util/references";
 import { type Section } from "../../util/sections";
 import * as ClassHydration from "./constants/class-hydration";
-declare const kChildOffsetScopeBinding: unique symbol;
 type ClassHydration = ClassHydration.Value;
 declare module "@marko/compiler" {
     interface MarkoMeta {
@@ -12,7 +10,6 @@ declare module "@marko/compiler" {
 }
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
-        [kChildOffsetScopeBinding]?: Binding;
         defineBodySection?: Section;
     }
 }

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

@@ -1,7 +1,8 @@
 import { types as t } from "@marko/compiler";
+declare const kAnalyzeFailed: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface MarkoTagExtra {
-        analyzeFailed?: boolean;
+        [kAnalyzeFailed]?: boolean;
     }
 }
 declare const _default: {

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

@@ -1,19 +1,34 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "../../util/references";
 import { type DOMRuntimeFeature } from "../../util/runtime";
-import { type StructureVisit } from "../../util/sections";
-export declare const kNativeTagBinding: unique symbol;
-export declare const kSkipEndTag: unique symbol;
-declare const kTagContentAttr: unique symbol;
-declare const kVisitOp: unique symbol;
+import { type StructureNode } from "../../util/sections";
+declare const kNodeOp: unique symbol;
+declare const kNativeAttrs: unique symbol;
 declare module "@marko/compiler/dist/types" {
-    interface NodeExtra {
-        [kNativeTagBinding]?: Binding;
-        [kSkipEndTag]?: true;
-        [kTagContentAttr]?: true;
-        [kVisitOp]?: StructureVisit;
+    interface MarkoTagExtra {
+        [kNodeOp]?: StructureNode;
+        [kNativeAttrs]?: NativeAttrs;
     }
 }
+interface NativeAttrs {
+    /** Attributes written on their own, apart from the controllable pair. */
+    own: number[] | undefined;
+    /** Event handlers the element attaches on its own, in source order. */
+    handlers: number[] | undefined;
+    /** The `content` attribute rendering in place of a body. */
+    content: number | undefined;
+    /** Attributes controlling an element state, its change handler second. */
+    controllable: Controllable | undefined;
+    /** Attributes written as one object with the spreads, in write order. */
+    spread: number[] | undefined;
+    /** No attribute sets the nonce the page requires of it. */
+    nonceUnset: boolean;
+}
+interface Controllable {
+    state: "checked" | "checkedValue" | "value" | "open";
+    special: boolean;
+    valueMode?: "attribute" | "dynamic";
+    attrs: (number | undefined)[];
+}
 declare const _default: {
     analyze: {
         enter(this: unknown, tag: t.NodePath<t.MarkoTag>): void;
@@ -33,4 +48,3 @@ export declare function controllableClaimFor(tagName: string | undefined): "_con
  * kind at run time, and a run-time tag name can be any of them. */
 export declare function controllableFeatureFor(tagName: string | undefined): "controllable" | "controllable-input" | "controllable-open" | "controllable-select" | "controllable-textarea" | undefined;
 export declare function enableControllable(feature: DOMRuntimeFeature | undefined): void;
-export declare function isPageElement(tagName: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.4.0",
+  "version": "6.4.2",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -57,8 +57,8 @@
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.4.0",
-    "marko": "5.39.44"
+    "@marko/runtime-tags": "npm:marko@6.4.2",
+    "marko": "5.39.45"
   },
   "engines": {
     "node": ">=22"

package/dist/translator/util/insertion-context.d.ts

@@ -1 +0,0 @@
-export declare function discardsWrapperChildren(tagName: string): boolean;

package/dist/translator/util/is-non-html-text.d.ts

@@ -1,3 +0,0 @@
-import { types as t } from "@marko/compiler";
-export declare function isNonHTMLText(placeholder: t.NodePath<t.MarkoPlaceholder | t.MarkoText>): boolean;
-export declare function isTextOnlyNativeTag(tag: t.NodePath<t.MarkoTag>): boolean;

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

@@ -1,11 +0,0 @@
-import { types as t } from "@marko/compiler";
-import { type Section } from "./sections";
-import { type SerializeReason, type SerializeReasons } from "./serialize-reasons";
-export declare function buildGroupMask(groups: {
-    value: number | t.Expression | undefined;
-    names: string;
-}[]): t.Expression | undefined;
-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;

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

@@ -1,37 +0,0 @@
-import { types as t } from "@marko/compiler";
-import { AccessorPrefix, AccessorProp } from "../../common/types";
-import { type Opt, Sorted, type SortedOneMany } from "./optional";
-import { type Binding, type KnownExprs, type ReferencedBindings, type Sources } from "./references";
-import { type ParamSerializeReasonGroups, type Section } from "./sections";
-export type SerializeReasons = SortedOneMany<Sources>;
-export declare const sourcesUtil: Sorted<Sources>;
-export type SerializeReason = Sources;
-export type SerializeKey = symbol & {
-    __serialize_key__: 1;
-};
-export declare function isSameReason(a: SerializeReason | undefined, b: SerializeReason | undefined): boolean;
-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: Opt<t.NodeExtra>, prop?: Binding | AccessorProp | symbol, prefix?: AccessorPrefix | symbol): void;
-export declare function addOwnerSerializeReason(from: Section, to: Section, reason: undefined | false | SerializeReason): void;
-export declare function isReasonDynamic(reason: undefined | SerializeReason): reason is Sources & {
-    state: undefined;
-    forced: undefined;
-};
-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 isOwnResumeReason(reason: SerializeReason | undefined): boolean;
-export declare function applySerializeExprs(section: Section): void;
-export declare function finalizeSerializeReason(section: Section): void;
-export declare function getSerializeReasonsVersion(): number;
-export declare function setParamReasonGroups(section: Section, groups: ParamSerializeReasonGroups): void;

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

@@ -1,6 +0,0 @@
-import { types as t } from "@marko/compiler";
-import { type Opt } from "./optional";
-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;