marko 6.4.1 → 6.4.3

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

@@ -39,12 +39,17 @@ export interface Binding {
     property: string | undefined;
     propertyAliases: Map<string, Binding>;
     excludeProperties: SortedOpt<string>;
+    /** Its properties code assigns in place (`obj.x = 1`), all of them for a
+     * computed one. */
+    assignedProperties: SortedOpt<string> | true;
     aliasOf: Binding | undefined;
     /** The value these `<for>` params iterate, by `of` or `in`. */
     iterates: {
         expr: t.NodeExtra;
         type: "of" | "in";
     } | undefined;
+    /** For an array rest, the source index it starts at: `rest[0]` of
+     * `[a, ...rest]` is the source's `[1]`. */
     restOffset: number | undefined;
     /** For a tag variable a child's `<return>` writes, the node binding of the
      * tag rendering that child. */
@@ -95,9 +100,11 @@ export interface Getter {
     invoked: boolean;
 }
 export declare const getBindings: () => Set<Binding>;
-export declare function createBinding(name: string, type: Binding["type"], refSection: Section, aliased?: Binding["aliasOf"], property?: string, excludeProperties?: SortedOpt<string>, loc?: t.SourceLocation | null, refDeclared?: boolean): Binding;
+export declare function createBinding(name: string, type: Binding["type"], refSection: Section, aliased?: Binding["aliasOf"], property?: string, excludeProperties?: SortedOpt<string>, loc?: t.SourceLocation | null, refDeclared?: boolean, restOffset?: number): Binding;
 export declare function reserveId(binding: Binding, offset: ReservedId): void;
 export declare function getOrCreatePropertyAlias(binding: Binding, property: string): Binding;
+export declare function addAssignedProperty(binding: Binding, property: string | undefined): void;
+export declare function getAssignedObject(binding: Binding): Binding | undefined;
 export declare function getPropertyAlias(binding: Binding | undefined, properties: Opt<string>): Binding | undefined;
 export declare function compareReferences(a: ReferencedBindings, b: ReferencedBindings): number;
 /**
@@ -113,6 +120,7 @@ export declare function someAlias<A>(binding: Binding, test: (binding: Binding,
 export declare function someAliased<A>(binding: Binding | undefined, test: (binding: Binding, arg: A) => boolean, arg: A): boolean;
 export declare function getNearestDeclared(binding: Binding): Binding | undefined;
 export declare function isDirectAlias(binding: Binding): boolean;
+export declare function isRest(binding: Binding): boolean;
 export declare function getDebugScopeAccess(binding: Binding): {
     root: Binding;
     access: string;

package/dist/translator/util/constants/structure-kind.d.ts

@@ -1,6 +1,7 @@
 export declare const Node = "node";
 export declare const Text = "text";
 export declare const Child = "child";
+export declare const ModuleRead = "moduleRead";
 export declare const SectionRef = "sectionRef";
 export declare const ExportRef = "exportRef";
 type Self = typeof import("./structure-kind");

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

@@ -14,7 +14,8 @@ declare module "@marko/compiler/dist/types" {
         [kKnownExprs]?: KnownExprs;
     }
 }
-export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, contentSection: Section, propTree: BindingPropTree | undefined): void;
+export declare function knownTagAnalyze(tag: t.NodePath<t.MarkoTag>, contentSection: Section, childParamsTree?: BindingPropTree): void;
+export declare function analyzeRecursiveTags(): void;
 export declare function knownTagTranslateHTML(tag: t.NodePath<t.MarkoTag>, tagIdentifier: t.Expression): void;
 export declare function knownTagTranslateDOM(tag: t.NodePath<t.MarkoTag>, getBindingIdentifier: (binding: Binding, preferredName?: string, directContent?: boolean) => t.Identifier, callSetup: ((section: Section, childBinding: Binding) => void) | undefined): void;
 export declare function finalizeKnownTags(section: Section): void;

package/dist/translator/util/module-read.d.ts

@@ -0,0 +1,21 @@
+import { types as t } from "@marko/compiler";
+declare const kModuleRead: unique symbol;
+declare module "@marko/compiler/dist/types" {
+    interface NodeExtra {
+        [kModuleRead]?: ModuleRead | null;
+    }
+}
+/** A read of an import binding (`styles.box`), set once its module loads. */
+export interface ModuleRead {
+    /** The binding's name, then the member names read from it. */
+    read: string[];
+    /** The import's source; none for a `<style/name>` tag's own stylesheet module. */
+    request: string | undefined;
+}
+/** The module read an expression is, resolved on first use: translate replaces
+ * a `<style/name>` tag. */
+export declare function getModuleRead(path: t.NodePath, expr: t.Expression): ModuleRead | undefined;
+/** A module read of a stylesheet module, whose reads are class name strings. */
+export declare function getStyleImportRead(path: t.NodePath, expr: t.Expression): string[] | undefined;
+export declare function toModuleReadExpression([name, ...members]: string[]): t.Identifier | t.MemberExpression;
+export {};

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

@@ -106,6 +106,7 @@ export declare function trackVarReferences(tag: t.NodePath<t.MarkoTag>, type: Bi
 export declare function trackParamsReferences(body: t.NodePath<t.MarkoTagBody | t.Program>, type: BindingType): Binding | undefined;
 export declare function isReferenceInOwnBody(bindingPath: t.NodePath, reference: t.NodePath): boolean;
 export declare function isReferenceHoisted(bindingPath: t.NodePath, reference: t.NodePath): boolean;
+export declare function assertReferencedInRender(ref: t.NodePath, name: string, markoRoot?: import("./get-root").MarkoExprRootPath | null): void;
 export declare function setReferencesScope(path: t.NodePath<any>): void;
 export declare function trackGlobalReference(path: t.NodePath<t.Identifier>): void;
 export declare function mergeReferences<T extends t.Node>(section: Section, target: T, nodes: (t.Node | undefined)[]): NonNullable<T["extra"]> & ReferencedExtra;

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

@@ -1,6 +1,7 @@
 import { types as t } from "@marko/compiler";
 import type { Falsy } from "../../common/types";
 import { _attr, _attr_class, _attr_style, _escape, _escape_script, _escape_style, _unescaped } from "../../html";
+import { escapeDoubleQuotedAttrValue } from "../../html/attrs";
 export type DOMRuntimeHelpers = keyof typeof import("../../dom");
 export type HTMLRuntimeHelpers = keyof typeof import("../../html");
 export declare function importRuntime(name: DOMRuntimeHelpers | HTMLRuntimeHelpers): t.Identifier;
@@ -19,6 +20,7 @@ export declare function getHTMLRuntime(): {
     _attr_style: typeof _attr_style;
     _escape_script: typeof _escape_script;
     _escape_style: typeof _escape_style;
+    escapeDoubleQuotedAttrValue: typeof escapeDoubleQuotedAttrValue;
 };
 export declare function getRuntimePath(output: string): string;
 export declare function getCompatRuntimeFile(): string;

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

@@ -23,7 +23,7 @@ export interface StructureExportRef {
     path: string;
     hint: string;
 }
-export type StructureOp = string | Step.Value | StructureText | StructureNode | StructureChild;
+export type StructureOp = string | Step.Value | StructureText | StructureNode | StructureChild | StructureModuleRead;
 export interface StructureText {
     kind: typeof StructureKind.Text;
     value: string;
@@ -39,6 +39,10 @@ export interface StructureChild {
     binding: Binding;
     renderer?: StructureRef;
 }
+export interface StructureModuleRead {
+    kind: typeof StructureKind.ModuleRead;
+    read: string[];
+}
 export interface Section {
     id: number;
     name: string;

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

@@ -7,6 +7,7 @@ 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 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.4.1",
+  "version": "6.4.3",
   "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.1",
-    "marko": "5.39.44"
+    "@marko/runtime-tags": "npm:marko@6.4.3",
+    "marko": "5.39.45"
   },
   "engines": {
     "node": ">=22"

package/tags-html.d.ts

@@ -2225,11 +2225,6 @@ declare global {
          */
         autocomplete?: AttrAutoComplete;
 
-        /**
-         * (Safari only). Controls the autocorrect behavior of the <textarea> element.
-         */
-        autocorrect?: AttrOnOff;
-
         /**
          * Specifies the visible width of the <textarea> element in terms of character width.
          * @see https://html.spec.whatwg.org/multipage/form-elements.html#attr-textarea-cols
@@ -4208,6 +4203,12 @@ declare global {
         | "sentences"
         | "words";
 
+      /**
+       * Controls whether user agents may autocorrect spelling while the user types.
+       * @see https://html.spec.whatwg.org/multipage/interaction.html#attr-autocorrect
+       */
+      autocorrect?: AttrOnOff;
+
       /**
        * Indicates whether the element should automatically get focus when the page loads.
        * @see https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute