marko 6.0.8 → 6.0.10

package/dist/translator/util/is-only-child-in-parent.d.ts

@@ -5,10 +5,10 @@ declare const kOnlyChildInParent: unique symbol;
 declare const kNodeRef: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
-        [kOnlyChildInParent]?: boolean;
+        [kOnlyChildInParent]?: false | string;
         [kNodeRef]?: Binding;
     }
 }
-export declare function isOnlyChildInParent(tag: t.NodePath<t.MarkoTag>, branchSize?: number): boolean;
+export declare function getOnlyChildParentTagName(tag: t.NodePath<t.MarkoTag>, branchSize?: number): string | false;
 export declare function getOptimizedOnlyChildNodeBinding(tag: t.NodePath<t.MarkoTag>, section: Section, branchSize?: number): Binding;
 export {};

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

@@ -19,6 +19,7 @@ export declare function forEach<T>(data: Opt<T>, cb: (item: T, index: number) =>
 export declare function fromIter<T>(data: Iterable<T>): T | Many<T> | undefined;
 export declare function find<T>(data: Opt<T>, cb: (item: T, index: number) => boolean): Opt<T>;
 export declare function toArray<T, R>(data: Opt<T>, cb: (item: T, index: number) => R): R[];
+export declare function mapToString<T>(data: Opt<T>, sep: string, cb: (item: T, index: number) => string): string;
 export declare function filterMap<T, R>(data: Opt<T>, cb: (item: T) => undefined | R): Opt<R>;
 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;

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

@@ -1,7 +1,6 @@
 import { types as t } from "@marko/compiler";
 import { type Many, type OneMany, 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 | {
@@ -15,6 +14,10 @@ export declare enum BindingType {
     derived = 4,
     hoist = 5
 }
+export interface Sources {
+    state: Opt<Binding>;
+    input: Opt<InputBinding>;
+}
 export interface Binding {
     id: number;
     name: string;
@@ -23,8 +26,7 @@ export interface Binding {
     section: Section;
     closureSections: Opt<Section>;
     assignmentSections: Opt<Section>;
-    sources: Opt<Binding>;
-    serializeSources: undefined | SerializeReason;
+    sources: undefined | Sources;
     aliases: Set<Binding>;
     hoists: Map<Section, Binding>;
     property: string | undefined;
@@ -72,13 +74,16 @@ export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody |
 export declare function trackHoistedReference(referencePath: t.NodePath<t.Identifier>, binding: Binding): void;
 export declare function setReferencesScope(path: t.NodePath<any>): void;
 export declare function mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]>;
-export declare function compareSerializeReasons(a: OneMany<InputBinding>, b: OneMany<InputBinding>): number;
+export declare function compareReferences(a: OneMany<Binding>, b: OneMany<Binding>): number;
 export declare function finalizeReferences(): void;
 export declare const intersectionMeta: WeakMap<Intersection, {
     id: number;
     scopeOffset: Binding | undefined;
 }>;
-export declare function setBindingValueExpr(binding: Binding, valueExpr: undefined | boolean | Opt<t.NodeExtra>): void;
+export declare function setBindingValueExpr(binding: Binding, valueExpr: boolean | Opt<t.NodeExtra>): void;
+export declare function createSources(state: Sources["state"], input: Sources["input"]): 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>;
 export declare function addReadToExpression(path: t.NodePath, binding: Binding, node?: t.Identifier | t.MemberExpression): ReferencedExtra;
 export declare function dropReferences(node: t.Node | t.Node[]): void;
@@ -86,6 +91,12 @@ export declare function getCanonicalBinding(binding?: Binding): Binding | undefi
 export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[]): t.Node[];
 export declare function getScopeAccessorLiteral(binding: Binding, includeId?: boolean): t.StringLiteral | t.NumericLiteral;
 export declare function getScopeAccessor(binding: Binding, includeId?: boolean): string;
+export declare function getDebugScopeAccess(binding: Binding): {
+    root: Binding;
+    access: string;
+};
+export declare function getDebugName(binding: Binding): string;
+export declare function getInputDebugName(binding: InputBinding): string;
 export declare function getSectionInstancesAccessor(section: Section): string;
 export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral | t.NumericLiteral | undefined;
 export declare function getReadReplacement(node: t.Identifier | t.MemberExpression): t.Node | undefined;

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

@@ -1,14 +1,10 @@
 import { types as t } from "@marko/compiler";
 import { AccessorPrefix, AccessorProp } from "../../common/types";
-import { type OneMany, type Opt } from "./optional";
-import { type Binding, type InputBinding, type ReferencedBindings } from "./references";
+import { type Opt } from "./optional";
+import { type Binding, type ReferencedBindings, type Sources } from "./references";
 import type { Section } from "./sections";
-export type DynamicSerializeReason = OneMany<InputBinding>;
-export type DynamicSerializeReasons = [
-    DynamicSerializeReason,
-    ...DynamicSerializeReason[]
-];
-export type SerializeReason = true | DynamicSerializeReason;
+export type SerializeReasons = true | [Sources, ...Sources[]];
+export type SerializeReason = true | Sources;
 export type SerializeKey = symbol & {
     __serialize_key__: 1;
 };
@@ -28,7 +24,9 @@ export declare function getSectionSerializeReason(section: Section, prop?: Acces
 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 getSerializeSourcesForExpr(expr: t.NodeExtra): true | InputBinding | import("./optional").Many<InputBinding> | undefined;
-export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra>): true | Opt<InputBinding>;
-export declare function getSerializeSourcesForRef(ref: ReferencedBindings): true | InputBinding | import("./optional").Many<InputBinding> | undefined;
-export declare function mergeSerializeReasons<T extends undefined | SerializeReason>(a: T, b: T): T;
+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;

package/dist/translator/util/with-comment.d.ts

@@ -0,0 +1,2 @@
+import type { types as t } from "@marko/compiler";
+export declare function withLeadingComment<T extends t.Node>(node: T, value: string): T;

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

@@ -1,8 +1,9 @@
 import { types as t } from "@marko/compiler";
-import type { DynamicSerializeReason } from "../../util/serialize-reasons";
+import type { SerializeReason, SerializeReasons } from "../../util/serialize-reasons";
 export declare function getTemplateContentName(): string;
-export declare function getExprIfSerialized<T extends undefined | boolean | DynamicSerializeReason, U extends t.Expression>(reason: T, expr: U): T extends {} ? U : undefined;
-export declare function getSerializeGuard(reason: DynamicSerializeReason): t.CallExpression;
+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,6 +1,10 @@
 import { types as t } from "@marko/compiler";
-import { type Binding } from "../../util/references";
-import type { DynamicSerializeReason, DynamicSerializeReasons, SerializeReason } from "../../util/serialize-reasons";
+import { type Binding, type Sources } from "../../util/references";
+export type InputSerializeReason = NonNullable<Sources["input"]>;
+export type InputSerializeReasons = [
+    InputSerializeReason,
+    ...InputSerializeReason[]
+];
 export declare let cleanIdentifier: t.Identifier;
 export declare let scopeIdentifier: t.Identifier;
 export declare function isScopeIdentifier(node: t.Node): node is t.Identifier;
@@ -14,8 +18,8 @@ export type TemplateExport = {
 export type TemplateExports = TemplateExport["props"];
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        inputSerializeReasons?: DynamicSerializeReasons;
-        returnSerializeReason?: SerializeReason;
+        inputSerializeReasons?: InputSerializeReasons;
+        returnSerializeReason?: InputSerializeReason | true;
         returnValueExpr?: t.NodeExtra;
         domExports?: {
             template: string;
@@ -40,4 +44,4 @@ declare const _default: {
     };
 };
 export default _default;
-export declare function resolveSerializeReasonId(inputSerializeReasons: DynamicSerializeReasons, reason: DynamicSerializeReason): number;
+export declare function resolveSerializeReasonId(inputSerializeReasons: InputSerializeReasons, reason: InputSerializeReason): number;

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

@@ -1,12 +1,12 @@
 import { types as t } from "@marko/compiler";
 import { type Binding } from "../../util/references";
 export declare const kNativeTagBinding: unique symbol;
-export declare const kSkipMark: unique symbol;
+export declare const kSkipEndTag: unique symbol;
 declare const kGetterId: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface NodeExtra {
         [kNativeTagBinding]?: Binding;
-        [kSkipMark]?: true;
+        [kSkipEndTag]?: true;
         [kGetterId]?: string;
     }
 }

package/package.json

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