@player-ui/player 0.8.0-next.0 → 0.8.0-next.10

package/dist/index.mjs

@@ -20,9 +20,9 @@ var toExpression = (value) => ({
   name: "Expression",
   value
 });
-var toPath = (path2) => ({
+var toPath = (path) => ({
   name: "PathNode",
-  path: path2
+  path
 });
 var toQuery = (key, value) => ({
   name: "Query",
@@ -39,60 +39,6 @@ var toConcatenatedNode = (values) => {
   };
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/binding-grammar/parsimmon/index.ts
-import flatten from "arr-flatten";
-import P from "parsimmon";
-var doubleQuote = P.string('"');
-var singleQuote = P.string("'");
-var backTick = P.string("`");
-var identifier = P.regex(/[\w\-@]+/).desc("identifier").map(toValue);
-var path;
-var futurePath = P.lazy(() => path);
-var nestedPath = futurePath.trim(P.optWhitespace).wrap(P.string("{{"), P.string("}}")).map(toPath);
-var nestedExpression = P.regex(/[^`]*/).wrap(backTick, backTick).map(toExpression);
-var segment = P.alt(identifier, nestedPath, nestedExpression).atLeast(1).map(flatten).map(toConcatenatedNode);
-var optionallyQuotedSegment = P.alt(
-  P.regex(/[^"]*/).wrap(doubleQuote, doubleQuote).map(toValue),
-  P.regex(/[^']*/).wrap(singleQuote, singleQuote).map(toValue),
-  segment
-);
-var query = P.seq(
-  optionallyQuotedSegment,
-  P.string("=").times(1, 3).trim(P.optWhitespace),
-  optionallyQuotedSegment
-).map(([key, , value]) => toQuery(key, value));
-var brackets = P.alt(query, optionallyQuotedSegment).trim(P.optWhitespace).wrap(P.string("["), P.string("]")).many();
-var segmentAndBrackets = P.seqMap(segment, brackets, (s, bs) => [s, ...bs]);
-path = P.sepBy(segmentAndBrackets, P.string(".")).map(flatten);
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/binding-grammar/ebnf/index.ts
-import { Grammars } from "ebnf";
-var parser = new Grammars.W3C.Parser(`
-value                      ::= segment_and_bracket (SEGMENT_SEPARATOR segment_and_bracket)*
-segment                    ::= concatenated | expression | modelRef | identifier  
-concatenated               ::= (expression | modelRef | identifier)+ 
-modelRef                   ::= OPEN_CURL OPEN_CURL value CLOSE_CURL CLOSE_CURL 
-identifier                 ::= [\\w\\-@]+
-query                      ::= WHITESPACE* optionally_quoted_segment WHITESPACE* EQUALS EQUALS? EQUALS? WHITESPACE* optionally_quoted_segment WHITESPACE*
-brackets                   ::= OPEN_BRACKET WHITESPACE* (query | optionally_quoted_segment) WHITESPACE* CLOSE_BRACKET 
-segment_and_bracket        ::= segment brackets*
-quoted_value               ::= [^"']*
-optionally_quoted_segment  ::= WHITESPACE* SINGLE_QUOTE quoted_value SINGLE_QUOTE WHITESPACE* | WHITESPACE* DOUBLE_QUOTE quoted_value DOUBLE_QUOTE WHITESPACE* | WHITESPACE* segment WHITESPACE*
-expression_value           ::= [^\`]*
-expression                 ::= BACK_TICK expression_value BACK_TICK
-
-EQUALS                     ::= "="
-SEGMENT_SEPARATOR          ::= "."
-SINGLE_QUOTE               ::= "'"
-DOUBLE_QUOTE               ::= '"'
-WHITESPACE                 ::= " "
-OPEN_CURL                  ::= "{"
-CLOSE_CURL                 ::= "}" 
-OPEN_BRACKET               ::= "[" 
-CLOSE_BRACKET              ::= "]"
-BACK_TICK                  ::= "\`" 
-`);
-
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/binding-grammar/custom/index.ts
 var SEGMENT_SEPARATOR = ".";
 var OPEN_CURL = "{";
@@ -123,14 +69,14 @@ var isIdentifierChar = (char) => {
   charCode === 125;
   return !matches;
 };
-var parse = (path2) => {
+var parse = (path) => {
   let index = 1;
-  let ch = path2.charAt(0);
+  let ch = path.charAt(0);
   const next = (expected) => {
     if (expected && ch !== expected) {
       throw new Error(`Expected char: ${expected} but got: ${ch}`);
     }
-    ch = path2.charAt(index);
+    ch = path.charAt(index);
     index += 1;
     return ch;
   };
@@ -139,7 +85,7 @@ var parse = (path2) => {
       next();
     }
   };
-  const identifier2 = () => {
+  const identifier = () => {
     if (!isIdentifierChar(ch)) {
       return;
     }
@@ -185,7 +131,7 @@ var parse = (path2) => {
       return toValue(value);
     }
   };
-  const nestedPath2 = () => {
+  const nestedPath = () => {
     if (ch === OPEN_CURL) {
       next(OPEN_CURL);
       next(OPEN_CURL);
@@ -195,8 +141,8 @@ var parse = (path2) => {
       return modelRef;
     }
   };
-  const simpleSegment = () => nestedPath2() ?? expression() ?? identifier2();
-  const segment2 = () => {
+  const simpleSegment = () => nestedPath() ?? expression() ?? identifier();
+  const segment = () => {
     const segments = [];
     let nextSegment = simpleSegment();
     while (nextSegment !== void 0) {
@@ -208,13 +154,13 @@ var parse = (path2) => {
     }
     return toConcatenatedNode(segments);
   };
-  const optionallyQuotedSegment2 = () => {
+  const optionallyQuotedSegment = () => {
     whitespace();
     if (ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE) {
-      const singleQuote2 = ch === SINGLE_QUOTE;
-      next(singleQuote2 ? SINGLE_QUOTE : DOUBLE_QUOTE);
+      const singleQuote = ch === SINGLE_QUOTE;
+      next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
       const id = regex(/[^'"]+/);
-      next(singleQuote2 ? SINGLE_QUOTE : DOUBLE_QUOTE);
+      next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
       return id;
     }
     return simpleSegment();
@@ -232,12 +178,12 @@ var parse = (path2) => {
     if (ch === OPEN_BRACKET) {
       next(OPEN_BRACKET);
       whitespace();
-      let value = optionallyQuotedSegment2();
+      let value = optionallyQuotedSegment();
       if (value) {
         whitespace();
         if (equals()) {
           whitespace();
-          const second = optionallyQuotedSegment2();
+          const second = optionallyQuotedSegment();
           value = toQuery(value, second);
           whitespace();
         }
@@ -252,7 +198,7 @@ var parse = (path2) => {
   };
   const parseSegmentAndBrackets = () => {
     const parsed = [];
-    const firstSegment = segment2();
+    const firstSegment = segment();
     if (firstSegment) {
       parsed.push(firstSegment);
       let bracketSegment = parseBracket();
@@ -326,12 +272,12 @@ function findInArray(array, key, value) {
 var BindingInstance = class _BindingInstance {
   constructor(raw, factory = (rawBinding) => new _BindingInstance(rawBinding)) {
     const split = Array.isArray(raw) ? raw : raw.split(".");
-    this.split = split.map((segment2) => {
-      if (typeof segment2 === "number") {
-        return segment2;
+    this.split = split.map((segment) => {
+      if (typeof segment === "number") {
+        return segment;
       }
-      const tryNum = Number(segment2);
-      return isNaN(tryNum) ? segment2 : tryNum;
+      const tryNum = Number(segment);
+      return isNaN(tryNum) ? segment : tryNum;
     });
     Object.freeze(this.split);
     this.joined = this.split.join(".");
@@ -418,13 +364,13 @@ function resolveBindingAST(bindingPathNode, options, hooks) {
     }
     throw new Error(`Unable to resolve value for node: ${node.name}`);
   }
-  function appendPathSegments(segment2) {
-    if (typeof segment2 === "string" && segment2.indexOf(".") > -1) {
-      segment2.split(".").forEach((i) => {
+  function appendPathSegments(segment) {
+    if (typeof segment === "string" && segment.indexOf(".") > -1) {
+      segment.split(".").forEach((i) => {
         context.path.push(maybeConvertToNum(i));
       });
     } else {
-      context.path.push(segment2);
+      context.path.push(segment);
     }
   }
   function resolveNode(_node) {
@@ -495,21 +441,21 @@ var BindingParser = class {
    * Takes a binding path, parses it, and returns an equivalent, normalized
    * representation of that path.
    */
-  normalizePath(path2, resolveOptions) {
-    if (!BINDING_BRACKETS_REGEX.test(path2) && LAZY_BINDING_REGEX.test(path2) && this.hooks.skipOptimization.call(path2) !== true) {
-      return { path: path2.split("."), updates: void 0 };
+  normalizePath(path, resolveOptions) {
+    if (!BINDING_BRACKETS_REGEX.test(path) && LAZY_BINDING_REGEX.test(path) && this.hooks.skipOptimization.call(path) !== true) {
+      return { path: path.split("."), updates: void 0 };
     }
-    const ast = this.parseCache[path2] ?? parse(path2);
-    this.parseCache[path2] = ast;
+    const ast = this.parseCache[path] ?? parse(path);
+    this.parseCache[path] = ast;
     if (typeof ast !== "object" || !ast?.status) {
       throw new TypeError(
-        `Cannot normalize path "${path2}": ${ast?.error ?? "Unknown Error."}`
+        `Cannot normalize path "${path}": ${ast?.error ?? "Unknown Error."}`
       );
     }
     try {
       return resolveBindingAST(ast.path, resolveOptions, this.hooks);
     } catch (e) {
-      throw new NestedError2(`Cannot resolve binding: ${path2}`, e);
+      throw new NestedError2(`Cannot resolve binding: ${path}`, e);
     }
   }
   getBindingForNormalizedResult(normalized) {
@@ -535,25 +481,25 @@ var BindingParser = class {
     let updates = {};
     const joined = Array.isArray(rawBinding) ? rawBinding.join(".") : String(rawBinding);
     const normalizeConfig = {
-      getValue: (path2) => {
-        const normalized2 = this.normalizePath(path2.join("."), normalizeConfig);
+      getValue: (path) => {
+        const normalized2 = this.normalizePath(path.join("."), normalizeConfig);
         return options.get(this.getBindingForNormalizedResult(normalized2));
       },
       evaluate: (exp) => {
         return options.evaluate(exp);
       },
-      convertToPath: (path2) => {
-        if (path2 === void 0) {
+      convertToPath: (path) => {
+        if (path === void 0) {
           throw new Error(
             "Attempted to convert undefined value to binding path"
           );
         }
-        if (typeof path2 !== "string" && typeof path2 !== "number" && typeof path2 !== "boolean") {
+        if (typeof path !== "string" && typeof path !== "number" && typeof path !== "boolean") {
           throw new Error(
-            `Attempting to convert ${typeof path2} to a binding path.`
+            `Attempting to convert ${typeof path} to a binding path.`
           );
         }
-        const normalized2 = this.normalizePath(String(path2), normalizeConfig);
+        const normalized2 = this.normalizePath(String(path), normalizeConfig);
         if (normalized2.updates) {
           updates = {
             ...updates,
@@ -1387,17 +1333,17 @@ function parseExpression(expr, options) {
         break;
       }
     }
-    const identifier2 = expr.slice(start, index);
-    if (Object.prototype.hasOwnProperty.call(literals, identifier2)) {
+    const identifier = expr.slice(start, index);
+    if (Object.prototype.hasOwnProperty.call(literals, identifier)) {
       return {
         __id: ExpNodeOpaqueIdentifier,
         type: "Literal",
-        value: literals[identifier2],
-        raw: identifier2,
+        value: literals[identifier],
+        raw: identifier,
         location: getLocation(start)
       };
     }
-    if (identifier2 === thisStr) {
+    if (identifier === thisStr) {
       return {
         __id: ExpNodeOpaqueIdentifier,
         type: "ThisExpression",
@@ -1407,7 +1353,7 @@ function parseExpression(expr, options) {
     return {
       __id: ExpNodeOpaqueIdentifier,
       type: "Identifier",
-      name: identifier2,
+      name: identifier,
       location: getLocation(start)
     };
   }
@@ -2038,7 +1984,7 @@ var ProxyLogger = class {
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/schema/schema.ts
 import { SyncWaterfallHook as SyncWaterfallHook3 } from "tapable-ts";
 var identify = (val) => val;
-function parse4(schema) {
+function parse2(schema) {
   const expandedPaths = /* @__PURE__ */ new Map();
   if (!schema.ROOT) {
     return expandedPaths;
@@ -2049,10 +1995,10 @@ function parse4(schema) {
     if (!next) {
       break;
     }
-    const { node, path: path2, visited } = next;
+    const { node, path, visited } = next;
     Object.entries(node).forEach(([prop, type]) => {
-      const nestedPath2 = [...path2, prop];
-      const nestedPathStr = nestedPath2.join(".");
+      const nestedPath = [...path, prop];
+      const nestedPathStr = nestedPath.join(".");
       if (expandedPaths.has(nestedPathStr)) {
         throw new Error(
           "Path has already been processed. There's either a loop somewhere or a bug"
@@ -2065,14 +2011,14 @@ function parse4(schema) {
       }
       expandedPaths.set(nestedPathStr, type);
       if (type.isArray) {
-        nestedPath2.push("[]");
+        nestedPath.push("[]");
       }
       if (type.isRecord) {
-        nestedPath2.push("{}");
+        nestedPath.push("{}");
       }
       if (type.type && schema[type.type]) {
         parseQueue.push({
-          path: nestedPath2,
+          path: nestedPath,
           node: schema[type.type],
           visited: /* @__PURE__ */ new Set([...visited, type.type])
         });
@@ -2090,7 +2036,7 @@ var SchemaController = class {
     this.hooks = {
       resolveTypeForBinding: new SyncWaterfallHook3()
     };
-    this.schema = schema ? parse4(schema) : /* @__PURE__ */ new Map();
+    this.schema = schema ? parse2(schema) : /* @__PURE__ */ new Map();
   }
   addFormatters(fns) {
     fns.forEach((def) => {
@@ -2440,7 +2386,7 @@ import dlv from "dlv";
 import { dequal } from "dequal";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/index.ts
-import { omit as omit2, setIn as setIn4 } from "timm";
+import { setIn as setIn4 } from "timm";
 import { SyncBailHook as SyncBailHook3, SyncWaterfallHook as SyncWaterfallHook4 } from "tapable-ts";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/types.ts
@@ -2459,8 +2405,14 @@ var NodeType = /* @__PURE__ */ ((NodeType2) => {
 })(NodeType || {});
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/utils.ts
-function hasAsync(obj) {
-  return Object.prototype.hasOwnProperty.call(obj, "async");
+function hasTemplateValues(obj, localKey) {
+  return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj?.template) && obj.template.length && obj.template.find((tmpl) => tmpl.output === localKey);
+}
+function hasSwitchKey(localKey) {
+  return localKey === "staticSwitch" || localKey === "dynamicSwitch";
+}
+function hasTemplateKey(localKey) {
+  return localKey === "template";
 }
 function getNodeID(node) {
   if (!node) {
@@ -2497,7 +2449,6 @@ var Parser = class {
        *   If null, we ignore this node all together
        */
       onCreateASTNode: new SyncWaterfallHook4(),
-      determineNodeType: new SyncBailHook3(),
       parseNode: new SyncBailHook3()
     };
   }
@@ -2508,21 +2459,6 @@ var Parser = class {
     }
     return viewNode;
   }
-  parseAsync(obj, type, options) {
-    const parsedAsync = this.parseObject(omit2(obj, "async"), type, options);
-    const parsedNodeId = getNodeID(parsedAsync);
-    if (parsedAsync !== null && parsedNodeId) {
-      return this.createASTNode(
-        {
-          id: parsedNodeId,
-          type: "async" /* Async */,
-          value: parsedAsync
-        },
-        obj
-      );
-    }
-    return null;
-  }
   createASTNode(node, value) {
     const tapped = this.hooks.onCreateASTNode.call(node, value);
     if (tapped === void 0) {
@@ -2530,32 +2466,16 @@ var Parser = class {
     }
     return tapped;
   }
-  /**
-   * Checks if there are templated values in the object
-   *
-   * @param obj - The Parsed Object to check to see if we have a template array type for
-   * @param localKey - The key being checked
-   */
-  hasTemplateValues(obj, localKey) {
-    return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj?.template) && obj.template.length && obj.template.find((tmpl) => tmpl.output === localKey);
-  }
-  hasSwitchKey(localKey) {
-    return localKey === "staticSwitch";
-  }
   parseObject(obj, type = "value" /* Value */, options = { templateDepth: 0 }) {
-    const nodeType = this.hooks.determineNodeType.call(obj);
-    if (nodeType !== void 0) {
-      const parsedNode = this.hooks.parseNode.call(
-        obj,
-        type,
-        options,
-        nodeType
-      );
-      if (parsedNode) {
-        return parsedNode;
-      }
+    const parsedNode = this.hooks.parseNode.call(
+      obj,
+      type,
+      options
+    );
+    if (parsedNode || parsedNode === null) {
+      return parsedNode;
     }
-    const parseLocalObject = (currentValue, objToParse, path2 = []) => {
+    const parseLocalObject = (currentValue, objToParse, path = []) => {
       if (typeof objToParse !== "object" || objToParse === null) {
         return { value: objToParse, children: [] };
       }
@@ -2575,182 +2495,44 @@ var Parser = class {
         value: currentValue
       };
       const newValue = objEntries.reduce((accumulation, current) => {
-        const { children: children2, ...rest } = accumulation;
+        let { value: value2 } = accumulation;
+        const { children: children2 } = accumulation;
         const [localKey, localValue] = current;
-        if (localKey === "asset" && typeof localValue === "object") {
-          const assetAST = this.parseObject(
-            localValue,
-            "asset" /* Asset */,
-            options
-          );
-          if (assetAST) {
-            return {
-              ...rest,
-              children: [
-                ...children2,
-                {
-                  path: [...path2, "asset"],
-                  value: assetAST
-                }
-              ]
-            };
-          }
-        } else if (this.hooks.determineNodeType.call(localKey) === "template" /* Template */ && Array.isArray(localValue)) {
-          const templateChildren = localValue.map((template) => {
-            const templateAST = this.hooks.onCreateASTNode.call(
-              {
-                type: "template" /* Template */,
-                depth: options.templateDepth ?? 0,
-                data: template.data,
-                template: template.value,
-                dynamic: template.dynamic ?? false
-              },
-              template
-            );
-            if (templateAST?.type === "multi-node" /* MultiNode */) {
-              templateAST.values.forEach((v) => {
-                v.parent = templateAST;
-              });
-            }
-            if (templateAST) {
-              return {
-                path: [...path2, template.output],
-                value: templateAST
-              };
-            }
-            return;
-          }).filter((element) => !!element);
-          return {
-            ...rest,
-            children: [...children2, ...templateChildren]
-          };
-        } else if (localValue && this.hooks.determineNodeType.call(localValue) === "switch" /* Switch */ || this.hasSwitchKey(localKey)) {
-          const localSwitch = this.hooks.parseNode.call(
-            this.hasSwitchKey(localKey) ? { [localKey]: localValue } : localValue,
-            "value" /* Value */,
-            options,
-            "switch" /* Switch */
-          );
-          if (localSwitch && localSwitch.type === "value" /* Value */ && localSwitch.children?.length === 1 && localSwitch.value === void 0) {
-            const firstChild = localSwitch.children[0];
-            return {
-              ...rest,
-              children: [
-                ...children2,
-                {
-                  path: [...path2, localKey, ...firstChild.path],
-                  value: firstChild.value
-                }
-              ]
-            };
-          }
-          if (localSwitch) {
-            return {
-              ...rest,
-              children: [
-                ...children2,
-                {
-                  path: [...path2, localKey],
-                  value: localSwitch
-                }
-              ]
-            };
-          }
-        } else if (localValue && hasAsync(localValue)) {
-          const localAsync = this.parseAsync(
-            localValue,
-            "value" /* Value */,
-            options
-          );
-          if (localAsync) {
-            children2.push({
-              path: [...path2, localKey],
-              value: localAsync
-            });
-          }
-        } else if (localValue && Array.isArray(localValue)) {
-          const childValues = localValue.map(
-            (childVal) => this.parseObject(childVal, "value" /* Value */, options)
-          ).filter((child) => !!child);
-          if (childValues.length > 0) {
-            const multiNode = this.hooks.onCreateASTNode.call(
-              {
-                type: "multi-node" /* MultiNode */,
-                override: !this.hasTemplateValues(localObj, localKey),
-                values: childValues
-              },
-              localValue
-            );
-            if (multiNode?.type === "multi-node" /* MultiNode */) {
-              multiNode.values.forEach((v) => {
-                v.parent = multiNode;
-              });
-            }
-            if (multiNode) {
-              return {
-                ...rest,
-                children: [
-                  ...children2,
-                  {
-                    path: [...path2, localKey],
-                    value: multiNode
-                  }
-                ]
-              };
-            }
+        const newChildren = this.hooks.parseNode.call(
+          localValue,
+          "value" /* Value */,
+          options,
+          {
+            path,
+            key: localKey,
+            parentObj: localObj
           }
+        );
+        if (newChildren) {
+          children2.push(...newChildren);
         } else if (localValue && typeof localValue === "object") {
-          const determineNodeType = this.hooks.determineNodeType.call(localValue);
-          if (determineNodeType === "applicability" /* Applicability */) {
-            const parsedNode = this.hooks.parseNode.call(
-              localValue,
-              "value" /* Value */,
-              options,
-              determineNodeType
-            );
-            if (parsedNode) {
-              return {
-                ...rest,
-                children: [
-                  ...children2,
-                  {
-                    path: [...path2, localKey],
-                    value: parsedNode
-                  }
-                ]
-              };
-            }
-          } else {
-            const result = parseLocalObject(accumulation.value, localValue, [
-              ...path2,
-              localKey
-            ]);
-            return {
-              value: result.value,
-              children: [...children2, ...result.children]
-            };
-          }
+          const result = parseLocalObject(accumulation.value, localValue, [
+            ...path,
+            localKey
+          ]);
+          value2 = result.value;
+          children2.push(...result.children);
         } else {
-          const value2 = setIn4(
-            accumulation.value,
-            [...path2, localKey],
-            localValue
-          );
-          return {
-            children: children2,
-            value: value2
-          };
+          value2 = setIn4(accumulation.value, [...path, localKey], localValue);
         }
-        return accumulation;
+        return {
+          value: value2,
+          children: children2
+        };
       }, defaultValue);
       return newValue;
     };
     const { value, children } = parseLocalObject(void 0, obj);
-    const baseAst = value === void 0 && children.length === 0 ? void 0 : {
+    const baseAst = value === void 0 && !children.length ? void 0 : {
       type,
       value
     };
-    if (baseAst !== void 0 && children.length > 0) {
+    if (baseAst && children.length) {
       const parent = baseAst;
       parent.children = children;
       children.forEach((child) => {
@@ -3105,13 +2887,13 @@ var Resolver = class {
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/view.ts
 var CrossfieldProvider = class {
-  constructor(initialView, parser2, logger) {
+  constructor(initialView, parser, logger) {
     this.allValidations = /* @__PURE__ */ new Set();
     this.byBinding = /* @__PURE__ */ new Map();
     this.logger = logger;
-    this.parse(initialView, parser2);
+    this.parse(initialView, parser);
   }
-  parse(contentView, parser2) {
+  parse(contentView, parser) {
     const xfieldRefs = contentView.validation;
     if (xfieldRefs === void 0) {
       return;
@@ -3131,7 +2913,7 @@ var CrossfieldProvider = class {
       this.allValidations.add(withDefaults);
       const { ref } = vRef;
       if (ref) {
-        const parsed = parser2(ref);
+        const parsed = parser(ref);
         if (this.byBinding.has(parsed)) {
           this.byBinding.get(parsed)?.push(withDefaults);
         } else {
@@ -3178,12 +2960,12 @@ var ViewInstance = class {
           "templatePlugin not set for View, legacy templates may not work"
         );
       }
-      const parser2 = new Parser();
-      this.hooks.parser.call(parser2);
-      this.rootNode = parser2.parseView(this.initialView);
+      const parser = new Parser();
+      this.hooks.parser.call(parser);
+      this.rootNode = parser.parseView(this.initialView);
       this.resolver = new Resolver(this.rootNode, {
         ...this.resolverOptions,
-        parseNode: parser2.parseObject.bind(parser2)
+        parseNode: parser.parseObject.bind(parser)
       });
       this.hooks.resolver.call(this.resolver);
     }
@@ -3248,10 +3030,10 @@ var Builder = class {
    * @param path - The path at which to add the child
    * @param child - The child node
    */
-  static addChild(node, path2, child) {
+  static addChild(node, path, child) {
     child.parent = node;
     const newChild = {
-      path: Array.isArray(path2) ? path2 : [path2],
+      path: Array.isArray(path) ? path : [path],
       value: child
     };
     node.children = node.children || [];
@@ -3260,7 +3042,7 @@ var Builder = class {
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/template-plugin.ts
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/template.ts
 import { SyncWaterfallHook as SyncWaterfallHook6 } from "tapable-ts";
 var TemplatePlugin = class {
   constructor(options) {
@@ -3315,39 +3097,44 @@ var TemplatePlugin = class {
     };
     return result;
   }
-  applyParser(parser2) {
-    parser2.hooks.onCreateASTNode.tap("template", (node) => {
+  applyParser(parser) {
+    parser.hooks.onCreateASTNode.tap("template", (node) => {
       if (node && node.type === "template" /* Template */ && !node.dynamic) {
         return this.parseTemplate(
-          parser2.parseObject.bind(parser2),
+          parser.parseObject.bind(parser),
           node,
           this.options
         );
       }
       return node;
     });
-    parser2.hooks.determineNodeType.tap("template", (obj) => {
-      if (obj === "template") {
-        return "template" /* Template */;
-      }
-    });
-    parser2.hooks.parseNode.tap(
+    parser.hooks.parseNode.tap(
       "template",
-      (obj, _nodeType, options, determinedNodeType) => {
-        if (determinedNodeType === "template" /* Template */) {
-          const templateNode = parser2.createASTNode(
-            {
-              type: "template" /* Template */,
-              depth: options.templateDepth ?? 0,
-              data: obj.data,
-              template: obj.value,
-              dynamic: obj.dynamic ?? false
-            },
-            obj
-          );
-          if (templateNode) {
-            return templateNode;
-          }
+      (obj, _nodeType, options, childOptions) => {
+        if (childOptions && hasTemplateKey(childOptions.key)) {
+          return obj.map((template) => {
+            const templateAST = parser.createASTNode(
+              {
+                type: "template" /* Template */,
+                depth: options.templateDepth ?? 0,
+                data: template.data,
+                template: template.value,
+                dynamic: template.dynamic ?? false
+              },
+              template
+            );
+            if (!templateAST)
+              return;
+            if (templateAST.type === "multi-node" /* MultiNode */) {
+              templateAST.values.forEach((v) => {
+                v.parent = templateAST;
+              });
+            }
+            return {
+              path: [...childOptions.path, template.output],
+              value: templateAST
+            };
+          }).filter(Boolean);
         }
       }
     );
@@ -3457,7 +3244,7 @@ var StringResolverPlugin = class {
           propsToSkip = /* @__PURE__ */ new Set(["exp"]);
         }
         const nodePath = findBasePath(node, resolver);
-        if (nodePath.length > 0 && nodePath.some((segment2) => propsToSkip.has(segment2.toString()))) {
+        if (nodePath.length > 0 && nodePath.some((segment) => propsToSkip.has(segment.toString()))) {
           return node.value;
         }
         return resolveAllRefs(node.value, options, propsToSkip);
@@ -3471,8 +3258,11 @@ var StringResolverPlugin = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/applicability.ts
-import { omit as omit3 } from "timm";
+import { omit as omit2 } from "timm";
 var ApplicabilityPlugin = class {
+  isApplicability(obj) {
+    return obj && Object.prototype.hasOwnProperty.call(obj, "applicability");
+  }
   applyResolver(resolver) {
     resolver.hooks.beforeResolve.tap(
       "applicability",
@@ -3489,35 +3279,39 @@ var ApplicabilityPlugin = class {
       }
     );
   }
-  applyParser(parser2) {
-    parser2.hooks.determineNodeType.tap("applicability", (obj) => {
-      if (Object.prototype.hasOwnProperty.call(obj, "applicability")) {
-        return "applicability" /* Applicability */;
-      }
-    });
-    parser2.hooks.parseNode.tap(
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
       "applicability",
-      (obj, nodeType, options, determinedNodeType) => {
-        if (determinedNodeType === "applicability" /* Applicability */) {
-          const parsedApplicability = parser2.parseObject(
-            omit3(obj, "applicability"),
+      (obj, nodeType, options, childOptions) => {
+        if (this.isApplicability(obj)) {
+          const parsedApplicability = parser.parseObject(
+            omit2(obj, "applicability"),
             nodeType,
             options
           );
-          if (parsedApplicability !== null) {
-            const applicabilityNode = parser2.createASTNode(
-              {
-                type: "applicability" /* Applicability */,
-                expression: obj.applicability,
-                value: parsedApplicability
-              },
-              obj
-            );
-            if (applicabilityNode?.type === "applicability" /* Applicability */) {
-              applicabilityNode.value.parent = applicabilityNode;
-            }
-            return applicabilityNode;
+          if (!parsedApplicability) {
+            return childOptions ? [] : null;
           }
+          const applicabilityNode = parser.createASTNode(
+            {
+              type: "applicability" /* Applicability */,
+              expression: obj.applicability,
+              value: parsedApplicability
+            },
+            obj
+          );
+          if (!applicabilityNode) {
+            return childOptions ? [] : null;
+          }
+          if (applicabilityNode.type === "applicability" /* Applicability */) {
+            applicabilityNode.value.parent = applicabilityNode;
+          }
+          return childOptions ? [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: applicabilityNode
+            }
+          ] : applicabilityNode;
         }
       }
     );
@@ -3542,58 +3336,67 @@ var SwitchPlugin = class {
     }
     return EMPTY_NODE;
   }
-  applyParser(parser2) {
-    parser2.hooks.onCreateASTNode.tap("switch", (node) => {
+  isSwitch(obj) {
+    return obj && (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch"));
+  }
+  applyParser(parser) {
+    parser.hooks.onCreateASTNode.tap("switch", (node) => {
       if (node && node.type === "switch" /* Switch */ && !node.dynamic) {
         return this.resolveSwitch(node, this.options);
       }
       return node;
     });
-    parser2.hooks.determineNodeType.tap("switch", (obj) => {
-      if (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch")) {
-        return "switch" /* Switch */;
-      }
-    });
-    parser2.hooks.parseNode.tap(
+    parser.hooks.parseNode.tap(
       "switch",
-      (obj, _nodeType, options, determinedNodeType) => {
-        if (determinedNodeType === "switch" /* Switch */) {
-          const dynamic = "dynamicSwitch" in obj;
-          const switchContent = "dynamicSwitch" in obj ? obj.dynamicSwitch : obj.staticSwitch;
-          const cases = [];
-          switchContent.forEach(
+      (obj, _nodeType, options, childOptions) => {
+        if (this.isSwitch(obj) || childOptions && hasSwitchKey(childOptions.key)) {
+          const objToParse = childOptions && hasSwitchKey(childOptions.key) ? { [childOptions.key]: obj } : obj;
+          const dynamic = "dynamicSwitch" in objToParse;
+          const switchContent = dynamic ? objToParse.dynamicSwitch : objToParse.staticSwitch;
+          const cases = switchContent.map(
             (switchCase) => {
               const { case: switchCaseExpr, ...switchBody } = switchCase;
-              const value = parser2.parseObject(
+              const value = parser.parseObject(
                 switchBody,
                 "value" /* Value */,
                 options
               );
               if (value) {
-                cases.push({
+                return {
                   case: switchCaseExpr,
                   value
-                });
+                };
               }
+              return;
             }
-          );
-          const switchAST = parser2.hooks.onCreateASTNode.call(
+          ).filter(Boolean);
+          const switchAST = parser.createASTNode(
             {
               type: "switch" /* Switch */,
               dynamic,
               cases
             },
-            obj
+            objToParse
           );
-          if (switchAST?.type === "switch" /* Switch */) {
+          if (!switchAST || switchAST.type === "empty" /* Empty */) {
+            return childOptions ? [] : null;
+          }
+          if (switchAST.type === "switch" /* Switch */) {
             switchAST.cases.forEach((sCase) => {
               sCase.value.parent = switchAST;
             });
           }
-          if (switchAST?.type === "empty" /* Empty */) {
-            return null;
+          if (childOptions) {
+            let path = [...childOptions.path, childOptions.key];
+            let value = switchAST;
+            if (switchAST.type === "value" /* Value */ && switchAST.children?.length === 1 && switchAST.value === void 0) {
+              const firstChild = switchAST.children[0];
+              path = [...path, ...firstChild.path];
+              value = firstChild.value;
+            }
+            return [{ path, value }];
           }
-          return switchAST ?? null;
+          return switchAST;
         }
       }
     );
@@ -3612,6 +3415,79 @@ var SwitchPlugin = class {
   }
 };
 
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/multi-node.ts
+var MultiNodePlugin = class {
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "multi-node",
+      (obj, nodeType, options, childOptions) => {
+        if (childOptions && !hasTemplateKey(childOptions.key) && Array.isArray(obj)) {
+          const values = obj.map(
+            (childVal) => parser.parseObject(childVal, "value" /* Value */, options)
+          ).filter((child) => !!child);
+          if (!values.length) {
+            return [];
+          }
+          const multiNode = parser.createASTNode(
+            {
+              type: "multi-node" /* MultiNode */,
+              override: !hasTemplateValues(
+                childOptions.parentObj,
+                childOptions.key
+              ),
+              values
+            },
+            obj
+          );
+          if (!multiNode) {
+            return [];
+          }
+          if (multiNode.type === "multi-node" /* MultiNode */) {
+            multiNode.values.forEach((v) => {
+              v.parent = multiNode;
+            });
+          }
+          return [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: multiNode
+            }
+          ];
+        }
+      }
+    );
+  }
+  apply(view) {
+    view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/asset.ts
+var AssetPlugin = class {
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "asset",
+      (obj, nodeType, options, childOptions) => {
+        if (childOptions?.key === "asset" && typeof obj === "object") {
+          const assetAST = parser.parseObject(obj, "asset" /* Asset */, options);
+          if (!assetAST) {
+            return [];
+          }
+          return [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: assetAST
+            }
+          ];
+        }
+      }
+    );
+  }
+  apply(view) {
+    view.hooks.parser.tap("asset", this.applyParser.bind(this));
+  }
+};
+
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/player.ts
 import { setIn as setIn7 } from "timm";
 import deferred from "p-defer";
@@ -4471,11 +4347,11 @@ var ValidationController = class {
   getValidationForBinding(binding) {
     return this.validations.get(binding);
   }
-  forView(parser2) {
+  forView(parser) {
     return {
       _getValidationForBinding: (binding) => {
         return this.getValidationForBinding(
-          isBinding(binding) ? binding : parser2(binding)
+          isBinding(binding) ? binding : parser(binding)
         );
       },
       getAll: () => {
@@ -4512,7 +4388,7 @@ var ValidationController = class {
           "Section functionality should be provided by the view plugin"
         );
       },
-      type: (binding) => this.schema.getType(isBinding(binding) ? binding : parser2(binding))
+      type: (binding) => this.schema.getType(isBinding(binding) ? binding : parser(binding))
     };
   }
 };
@@ -4954,7 +4830,7 @@ var DataController = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/constants/utils.ts
-function flatten2(obj, roots = [], sep = ".") {
+function flatten(obj, roots = [], sep = ".") {
   return Object.keys(obj).reduce(
     (memo, prop) => ({
       // create a new object
@@ -4962,7 +4838,7 @@ function flatten2(obj, roots = [], sep = ".") {
       ...memo,
       ...Object.prototype.toString.call(obj[prop]) === "[object Object]" ? (
         // keep working if value is an object
-        flatten2(obj[prop], roots.concat([prop]))
+        flatten(obj[prop], roots.concat([prop]))
       ) : (
         // include current prop and value and prefix prop with the roots
         { [roots.concat([prop]).join(sep)]: obj[prop] }
@@ -4972,7 +4848,7 @@ function flatten2(obj, roots = [], sep = ".") {
   );
 }
 function objectToBatchSet(obj) {
-  const flattenedObj = flatten2(obj);
+  const flattenedObj = flatten(obj);
   const batchTxn = [];
   Object.keys(flattenedObj).forEach((key) => {
     batchTxn.push([new BindingInstance(key), flattenedObj[key]]);
@@ -4994,8 +4870,8 @@ var ConstantsController = class {
     }
   }
   getConstants(key, namespace, fallback) {
-    const path2 = new BindingInstance(key);
-    return this.tempStore.get(namespace)?.get(path2) ?? this.store.get(namespace)?.get(path2) ?? fallback;
+    const path = new BindingInstance(key);
+    return this.tempStore.get(namespace)?.get(path) ?? this.store.get(namespace)?.get(path) ?? fallback;
   }
   setTemporaryValues(data, namespace) {
     if (this.tempStore.has(namespace)) {
@@ -5101,12 +4977,14 @@ var DefaultViewPlugin = class {
     player.hooks.viewController.tap(this.name, (viewController) => {
       viewController.hooks.view.tap(this.name, (view) => {
         const pluginOptions = toNodeResolveOptions(view.resolverOptions);
+        new AssetPlugin().apply(view);
         new SwitchPlugin(pluginOptions).apply(view);
         new ApplicabilityPlugin().apply(view);
         new StringResolverPlugin().apply(view);
         const templatePlugin = new TemplatePlugin(pluginOptions);
         templatePlugin.apply(view);
         view.hooks.onTemplatePluginCreated.call(templatePlugin);
+        new MultiNodePlugin().apply(view);
       });
     });
   }
@@ -5451,6 +5329,7 @@ _Player.info = {
 var Player = _Player;
 export {
   ApplicabilityPlugin,
+  AssetPlugin,
   AssetTransformCorePlugin,
   BINDING_BRACKETS_REGEX,
   BindingInstance,
@@ -5470,6 +5349,7 @@ export {
   FlowInstance,
   LocalModel,
   LocalStateStore,
+  MultiNodePlugin,
   NOOPDataModel,
   NOOP_MODEL,
   NOT_STARTED_STATE,
@@ -5503,13 +5383,15 @@ export {
   findNextExp,
   getBindingSegments,
   getNodeID,
-  hasAsync,
+  hasSwitchKey,
+  hasTemplateKey,
+  hasTemplateValues,
   isBinding,
   isErrorWithLocation,
   isExpressionNode,
   isObjectExpression,
   maybeConvertToNum,
-  parse4 as parse,
+  parse2 as parse,
   parseExpression,
   removeBindingAndChildrenFromMap,
   resolveDataRefs,