marko 6.3.56 → 6.4.1

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

@@ -0,0 +1,50 @@
+import { types as t } from "@marko/compiler";
+import { type Binding } from "./bindings";
+import * as SlotKind from "./constants/slot-kind";
+import { type Opt } from "./optional";
+import { type Reason } from "./reasons";
+import { type ParamReasonGroup, type Section } from "./sections";
+type SlotKind = SlotKind.Value;
+export { SlotKind };
+export type BindingSlotKind = typeof SlotKind.Value | typeof SlotKind.ChangeHandler | typeof SlotKind.ClosureScopes | typeof SlotKind.ClosureSignalIndex | typeof SlotKind.BranchExpr | typeof SlotKind.ParamGroup;
+export type SectionSlotKind = Exclude<SlotKind, BindingSlotKind>;
+export type PlaceSlotKind = typeof SlotKind.Value | typeof SlotKind.ChangeHandler | typeof SlotKind.ClosureScopes | typeof SlotKind.ClosureSignalIndex | typeof SlotKind.Owner | typeof SlotKind.ReturnChangeHandler | typeof SlotKind.Instances;
+/** A place in a scope that client code may read after resume, or a fact about
+ * one a guard decides on (a condition changing, a branch or group resuming). */
+export type Slot = BindingSlot | SectionSlot;
+export type PlaceSlot = Slot & {
+    kind: PlaceSlotKind;
+};
+interface BaseSlot {
+    /** The scope it is in. */
+    section: Section;
+    /** The sources whose changes lead client code to read it after resume,
+     * unset while nothing does. */
+    reason: Reason | undefined;
+    /** The expressions it holds or renders, whose sources its reason takes once
+     * references finalize. */
+    reasonExprs: Opt<t.NodeExtra>;
+}
+export interface BindingSlot extends BaseSlot {
+    kind: BindingSlotKind;
+    /** A canonical binding. */
+    owner: Binding;
+    /** The group it guards, for a param group. */
+    group: ParamReasonGroup | undefined;
+}
+export interface SectionSlot extends BaseSlot {
+    kind: SectionSlotKind;
+    owner: Section;
+    group: undefined;
+}
+export declare function getSlot(binding: Binding, kind?: BindingSlotKind, section?: Section, group?: ParamReasonGroup): Slot;
+export declare function findSlot(binding: Binding): (BindingSlot & {
+    kind: typeof SlotKind.Value;
+}) | undefined;
+export declare function findSlot<K extends BindingSlotKind>(binding: Binding, kind: K, section?: Section, group?: ParamReasonGroup): (BindingSlot & {
+    kind: K;
+}) | undefined;
+export declare function getSectionSlot(owner: Section, kind: SectionSlotKind, section?: Section): Slot;
+export declare function findSectionSlot<K extends SectionSlotKind>(owner: Section, kind: K, section?: Section): (SectionSlot & {
+    kind: K;
+}) | undefined;

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

@@ -0,0 +1,10 @@
+import { types as t } from "@marko/compiler";
+import { type Binding, type Intersection } from "./bindings";
+import { type Opt } from "./optional";
+import { type Reason } from "./reasons";
+import { type Section } from "./sections";
+export declare function solveReasons(intersectionsBySection: Map<Section, Intersection[]>): void;
+export declare function getReasonForBinding(binding: Binding, properties?: Opt<string> | true): undefined | Reason;
+export declare function getValueReason(extra: t.NodeExtra): undefined | Reason;
+export declare function readsValuesOnResume(expr: t.NodeExtra): boolean;
+export declare function addAlwaysRead(binding: Binding): void;

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,16 @@
 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 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.3.56",
+  "version": "6.4.1",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,13 +51,13 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.9",
+    "@marko/compiler": "^5.42.10",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.3.56",
+    "@marko/runtime-tags": "npm:marko@6.4.1",
     "marko": "5.39.44"
   },
   "engines": {

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 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 hasOwnResumeReason(section: Section): boolean;
-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 +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;

package/dist/translator/util/setup-statements.d.ts

@@ -1,5 +0,0 @@
-import type { types as t } from "@marko/compiler";
-import type { Section } from "./sections";
-export declare function addSetupStatement(section: Section): void;
-export declare function addSetupExpr(section: Section, node: t.Node | undefined): void;
-export declare function sectionHasSetupStatements(section: Section): boolean;