@archie/devtools 0.0.25 → 0.0.27

package/dist/collection-binding.js

@@ -0,0 +1,553 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/babel-plugin-collection-binding.ts
+var babel_plugin_collection_binding_exports = {};
+__export(babel_plugin_collection_binding_exports, {
+  babelPluginCollectionBinding: () => babelPluginCollectionBinding
+});
+module.exports = __toCommonJS(babel_plugin_collection_binding_exports);
+var import_types = require("@babel/types");
+
+// src/babel-plugin-editor-meta.ts
+function meaningfulChildren(t, children) {
+  return children.filter((child) => {
+    if (t.isJSXText(child)) return child.value.trim() !== "";
+    if (t.isJSXExpressionContainer(child)) return !t.isJSXEmptyExpression(child.expression);
+    return true;
+  });
+}
+
+// src/babel-plugin-collection-binding.ts
+var ATTR_ENTITY = "data-agent-entity";
+var ATTR_ROW = "data-agent-row";
+var ATTR_FIELD = "data-agent-field";
+var ATTR_FIELD_STATE = "data-agent-field-state";
+var ATTR_FIELD_PARTS = "data-agent-field-parts";
+var ATTR_FIELD_SLOT = "data-agent-field-slot";
+var ATTR_COLLECTION_ORDER = "data-agent-collection-order";
+var SLICE_ROOT_NAME = "slice";
+var CHAIN_METHODS = /* @__PURE__ */ new Set(["filter", "slice", "sort", "map"]);
+var MAX_SOURCE_CHAIN_HOPS = 4;
+var MAX_PROJECTION_DEPTH = 3;
+function babelPluginCollectionBinding({ types: t }, opts = {}) {
+  const { fileExclude = /node_modules/ } = opts;
+  function hasOwnAttr(elementPath, name) {
+    return elementPath.node.openingElement.attributes.some(
+      (a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name })
+    );
+  }
+  function addAttr(elementPath, name, value) {
+    if (hasOwnAttr(elementPath, name)) return;
+    elementPath.node.openingElement.attributes.push(t.jsxAttribute(t.jsxIdentifier(name), value));
+  }
+  function getTagName(opening) {
+    const { name } = opening;
+    if (t.isJSXIdentifier(name)) return name.name;
+    if (t.isJSXMemberExpression(name)) {
+      const parts = [];
+      let current = name;
+      while (t.isJSXMemberExpression(current)) {
+        parts.unshift(current.property.name);
+        current = current.object;
+      }
+      if (t.isJSXIdentifier(current)) parts.unshift(current.name);
+      return parts.join(".");
+    }
+    return "";
+  }
+  function isLowercaseTag(tag) {
+    return tag.length > 0 && tag[0] === tag[0].toLowerCase();
+  }
+  function getAttrName(attr) {
+    return t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+  }
+  function isPageSliceBinding(scope) {
+    const binding = scope.getBinding(SLICE_ROOT_NAME);
+    if (!binding) return true;
+    return binding.scope === binding.scope.getProgramParent();
+  }
+  function isUseMemoCallee(callee) {
+    if (t.isIdentifier(callee, { name: "useMemo" })) return true;
+    return t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property, { name: "useMemo" });
+  }
+  function resolveSliceSource(expr, scope, hops, hasSort) {
+    if (t.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (!t.isExpression(callee)) return null;
+      if (isUseMemoCallee(callee)) {
+        const [factory] = expr.arguments;
+        if (!factory || !t.isArrowFunctionExpression(factory)) return null;
+        if (!t.isExpression(factory.body)) return null;
+        return resolveSliceSource(factory.body, scope, hops, hasSort);
+      }
+      if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property)) {
+        const method = callee.property.name;
+        if (!CHAIN_METHODS.has(method)) return null;
+        if (!t.isExpression(callee.object)) return null;
+        return resolveSliceSource(callee.object, scope, hops, hasSort || method === "sort");
+      }
+      return null;
+    }
+    if (t.isMemberExpression(expr)) {
+      if (!t.isIdentifier(expr.object, { name: SLICE_ROOT_NAME })) return null;
+      if (!isPageSliceBinding(scope)) return null;
+      if (!expr.computed && t.isIdentifier(expr.property)) {
+        return { entity: expr.property.name, hasSort };
+      }
+      if (expr.computed && t.isStringLiteral(expr.property)) {
+        return { entity: expr.property.value, hasSort };
+      }
+      return null;
+    }
+    if (t.isIdentifier(expr)) {
+      if (hops >= MAX_SOURCE_CHAIN_HOPS) return null;
+      const binding = scope.getBinding(expr.name);
+      if (!binding || !binding.constant) return null;
+      const declarator = binding.path;
+      if (!declarator.isVariableDeclarator()) return null;
+      const init = declarator.node.init;
+      if (!init || !t.isExpression(init)) return null;
+      return resolveSliceSource(init, declarator.scope, hops + 1, hasSort);
+    }
+    return null;
+  }
+  function buildScopeFromParam(param) {
+    if (t.isIdentifier(param)) {
+      return { identifiers: /* @__PURE__ */ new Map([[param.name, { kind: "self" }]]) };
+    }
+    if (t.isObjectPattern(param)) {
+      const identifiers = /* @__PURE__ */ new Map();
+      for (const prop of param.properties) {
+        if (!t.isObjectProperty(prop) || prop.computed) continue;
+        const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+        if (!key || key.includes(",")) continue;
+        const value = prop.value;
+        let localName = null;
+        if (t.isIdentifier(value)) localName = value.name;
+        else if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) localName = value.left.name;
+        if (!localName) continue;
+        identifiers.set(localName, { kind: "field", field: key });
+      }
+      if (identifiers.size === 0) return null;
+      return { identifiers };
+    }
+    return null;
+  }
+  function buildOptionalRowIdExpression(idValueExpr) {
+    return t.conditionalExpression(
+      t.binaryExpression("==", t.cloneNode(idValueExpr), t.nullLiteral()),
+      t.identifier("undefined"),
+      t.callExpression(t.identifier("String"), [idValueExpr])
+    );
+  }
+  function computeRowIdExpression(scope) {
+    for (const [localName, binding] of scope.identifiers) {
+      if (binding.kind === "self") {
+        return buildOptionalRowIdExpression(
+          t.optionalMemberExpression(t.identifier(localName), t.identifier("id"), false, true)
+        );
+      }
+    }
+    for (const [localName, binding] of scope.identifiers) {
+      if (binding.kind === "field" && binding.field === "id") {
+        return buildOptionalRowIdExpression(t.identifier(localName));
+      }
+    }
+    return null;
+  }
+  function isStaticLiteralExpr(node) {
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node)) {
+      return true;
+    }
+    return t.isTemplateLiteral(node) && node.expressions.length === 0;
+  }
+  function containsEvaluation(node) {
+    if (!node) return false;
+    if (t.isCallExpression(node) || t.isOptionalCallExpression(node) || t.isNewExpression(node) || t.isTaggedTemplateExpression(node)) {
+      return true;
+    }
+    const keys = import_types.VISITOR_KEYS[node.type] ?? [];
+    for (const key of keys) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const child of value) {
+          if (child && typeof child === "object" && "type" in child) {
+            if (containsEvaluation(child)) return true;
+          }
+        }
+      } else if (value && typeof value === "object" && "type" in value) {
+        if (containsEvaluation(value)) return true;
+      }
+    }
+    return false;
+  }
+  function classifyMemberField(expr, scope) {
+    if (!t.isIdentifier(expr.object)) return null;
+    const binding = scope.identifiers.get(expr.object.name);
+    if (!binding || binding.kind !== "self") return null;
+    if (!expr.computed) {
+      if (!t.isIdentifier(expr.property)) return null;
+      if (expr.property.name === "id") return null;
+      return { kind: "static", field: expr.property.name };
+    }
+    if (t.isStringLiteral(expr.property)) {
+      if (expr.property.value === "id") return null;
+      if (expr.property.value.includes(",")) return null;
+      return { kind: "static", field: expr.property.value };
+    }
+    return { kind: "unresolved-computed" };
+  }
+  function fieldNameForBranch(expr, scope) {
+    if (t.isIdentifier(expr)) {
+      const binding = scope.identifiers.get(expr.name);
+      return binding?.kind === "field" ? binding.field : null;
+    }
+    if (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
+      const verdict = classifyMemberField(expr, scope);
+      return verdict?.kind === "static" ? verdict.field : null;
+    }
+    return null;
+  }
+  function flattenNullish(expr) {
+    const parts = [];
+    let current = expr;
+    while (t.isLogicalExpression(current) && current.operator === "??") {
+      parts.unshift(current.right);
+      current = current.left;
+    }
+    parts.unshift(current);
+    return parts;
+  }
+  function classifyNullishChain(expr, scope) {
+    const parts = flattenNullish(expr);
+    if (parts.length < 2) return null;
+    const last = parts[parts.length - 1];
+    if (parts.length === 2 && isStaticLiteralExpr(last)) {
+      const field = fieldNameForBranch(parts[0], scope);
+      return field ? { kind: "static", field } : null;
+    }
+    const fields = parts.map((p) => fieldNameForBranch(p, scope));
+    if (fields.some((f) => f === null)) return null;
+    const distinct = new Set(fields);
+    if (distinct.size === 1) return { kind: "static", field: fields[0] };
+    let acc = t.stringLiteral(fields[fields.length - 1]);
+    for (let i = parts.length - 2; i >= 0; i -= 1) {
+      acc = t.conditionalExpression(
+        t.binaryExpression("!=", t.cloneNode(parts[i]), t.nullLiteral()),
+        t.stringLiteral(fields[i]),
+        acc
+      );
+    }
+    return { kind: "runtime", expr: acc };
+  }
+  function classifySimpleLogicalOr(expr, scope) {
+    if (!isStaticLiteralExpr(expr.right)) return null;
+    const field = fieldNameForBranch(expr.left, scope);
+    return field ? { kind: "static", field } : null;
+  }
+  function classifyConditional(expr, scope) {
+    const { test, consequent, alternate } = expr;
+    if (!t.isExpression(test) || !t.isExpression(consequent) || !t.isExpression(alternate)) return null;
+    if (isStaticLiteralExpr(consequent) && isStaticLiteralExpr(alternate)) {
+      const testField = fieldNameForBranch(test, scope);
+      return testField ? { kind: "static", field: testField } : null;
+    }
+    const consField = fieldNameForBranch(consequent, scope);
+    const altField = fieldNameForBranch(alternate, scope);
+    if (!consField || !altField) return null;
+    if (consField === altField) return { kind: "static", field: consField };
+    if (containsEvaluation(test)) return null;
+    return {
+      kind: "runtime",
+      expr: t.conditionalExpression(t.cloneNode(test), t.stringLiteral(consField), t.stringLiteral(altField))
+    };
+  }
+  function classifyFieldExpr(expr, scope) {
+    if (t.isIdentifier(expr)) {
+      const binding = scope.identifiers.get(expr.name);
+      return binding?.kind === "field" ? { kind: "static", field: binding.field } : null;
+    }
+    if (t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr)) {
+      return classifyMemberField(expr, scope);
+    }
+    if (t.isLogicalExpression(expr) && expr.operator === "??") return classifyNullishChain(expr, scope);
+    if (t.isLogicalExpression(expr) && expr.operator === "||") return classifySimpleLogicalOr(expr, scope);
+    if (t.isConditionalExpression(expr)) return classifyConditional(expr, scope);
+    return null;
+  }
+  function applyFieldVerdict(elementPath, verdict) {
+    if (!verdict) return;
+    if (verdict.kind === "unresolved-computed") {
+      addAttr(elementPath, ATTR_FIELD_STATE, t.stringLiteral("unresolved"));
+      return;
+    }
+    if (verdict.kind === "static") {
+      addAttr(elementPath, ATTR_FIELD, t.stringLiteral(verdict.field));
+      return;
+    }
+    addAttr(elementPath, ATTR_FIELD, t.jsxExpressionContainer(verdict.expr));
+  }
+  function meaningfulChildPaths(elementPath) {
+    const meaningfulSet = new Set(meaningfulChildren(t, elementPath.node.children));
+    const childPaths = elementPath.get("children");
+    return childPaths.filter((p) => meaningfulSet.has(p.node));
+  }
+  function isStaticExpressionContainer(container) {
+    if (t.isJSXEmptyExpression(container.expression)) return true;
+    return isStaticLiteralExpr(container.expression);
+  }
+  function isInvisibleRenderExpr(expr) {
+    if (t.isNullLiteral(expr)) return true;
+    if (t.isBooleanLiteral(expr)) return true;
+    if (t.isStringLiteral(expr) && expr.value === "") return true;
+    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0 && expr.quasis.length === 1 && expr.quasis[0].value.cooked === "") {
+      return true;
+    }
+    return false;
+  }
+  function stampPureLeaf(elementPath, expr, scope) {
+    if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    if (t.isJSXEmptyExpression(expr) || !t.isExpression(expr)) return;
+    applyFieldVerdict(elementPath, classifyFieldExpr(expr, scope));
+  }
+  function stampLabelValueOrMixed(elementPath, childPaths, scope) {
+    if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    const hasInvisibleSibling = childPaths.some(
+      (p) => p.isJSXExpressionContainer() && t.isExpression(p.node.expression) && isInvisibleRenderExpr(p.node.expression)
+    );
+    if (hasInvisibleSibling) return;
+    const dynamicEntries = [];
+    childPaths.forEach((p, index) => {
+      if (!p.isJSXExpressionContainer()) return;
+      const container = p.node;
+      if (isStaticExpressionContainer(container)) return;
+      if (!t.isExpression(container.expression)) return;
+      dynamicEntries.push({ index, expr: container.expression });
+    });
+    if (dynamicEntries.length === 0) return;
+    if (dynamicEntries.length === 1) {
+      const { index, expr } = dynamicEntries[0];
+      const verdict = classifyFieldExpr(expr, scope);
+      if (!verdict) return;
+      applyFieldVerdict(elementPath, verdict);
+      if (verdict.kind !== "unresolved-computed") {
+        addAttr(elementPath, ATTR_FIELD_SLOT, t.stringLiteral(String(index)));
+      }
+      return;
+    }
+    const fields = [];
+    for (const { expr } of dynamicEntries) {
+      const verdict = classifyFieldExpr(expr, scope);
+      if (!verdict || verdict.kind !== "static") return;
+      fields.push(verdict.field);
+    }
+    if (new Set(fields).size <= 1) return;
+    addAttr(elementPath, ATTR_FIELD_STATE, t.stringLiteral("mixed"));
+    addAttr(elementPath, ATTR_FIELD_PARTS, t.stringLiteral(fields.join(",")));
+  }
+  function resolveComponentDefinition(tagName, fromPath) {
+    if (tagName.includes(".")) return null;
+    const binding = fromPath.scope.getBinding(tagName);
+    if (!binding) return null;
+    if (binding.scope !== binding.scope.getProgramParent()) return null;
+    const bp = binding.path;
+    if (bp.isFunctionDeclaration()) return bp;
+    if (bp.isVariableDeclarator()) {
+      const init = bp.get("init");
+      if (!Array.isArray(init) && (init.isArrowFunctionExpression() || init.isFunctionExpression())) {
+        return init;
+      }
+    }
+    return null;
+  }
+  function buildCalleePropContext(fnPath) {
+    const [first] = fnPath.node.params;
+    if (!first || !t.isObjectPattern(first)) return null;
+    const propMap = /* @__PURE__ */ new Map();
+    for (const prop of first.properties) {
+      if (!t.isObjectProperty(prop) || prop.computed) continue;
+      const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      const value = prop.value;
+      let localName = null;
+      if (t.isIdentifier(value)) localName = value.name;
+      else if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) localName = value.left.name;
+      if (!localName) continue;
+      propMap.set(key, localName);
+    }
+    if (propMap.size === 0) return null;
+    return { propMap };
+  }
+  function findReturnedJsxPath(fnPath) {
+    const body = fnPath.get("body");
+    if (Array.isArray(body)) return null;
+    if (body.isBlockStatement()) {
+      const returnPaths = [];
+      body.traverse({
+        Function(inner) {
+          inner.skip();
+        },
+        ReturnStatement(rp) {
+          returnPaths.push(rp);
+        }
+      });
+      if (returnPaths.length !== 1) return null;
+      const arg = returnPaths[0].get("argument");
+      if (Array.isArray(arg) || !arg.node) return null;
+      return arg.isJSXElement() ? arg : null;
+    }
+    return body.isJSXElement() ? body : null;
+  }
+  function findSelfForwardingLocalName(usagePath, scope, propCtx) {
+    for (const attr of usagePath.node.openingElement.attributes) {
+      if (!t.isJSXAttribute(attr)) continue;
+      const localName = propCtx.propMap.get(getAttrName(attr));
+      if (!localName) continue;
+      const value = attr.value;
+      if (!t.isJSXExpressionContainer(value)) continue;
+      const expr = value.expression;
+      if (!t.isIdentifier(expr)) continue;
+      const binding = scope.identifiers.get(expr.name);
+      if (binding?.kind === "self") return localName;
+    }
+    return null;
+  }
+  function resolveRowRoot(jsxPath, scope, depth) {
+    const tag = getTagName(jsxPath.node.openingElement);
+    if (isLowercaseTag(tag)) return { hostPath: jsxPath, scope };
+    if (depth >= MAX_PROJECTION_DEPTH) return null;
+    const fnPath = resolveComponentDefinition(tag, jsxPath);
+    if (!fnPath) return null;
+    const propCtx = buildCalleePropContext(fnPath);
+    if (!propCtx) return null;
+    const localName = findSelfForwardingLocalName(jsxPath, scope, propCtx);
+    if (!localName) return null;
+    const innerReturn = findReturnedJsxPath(fnPath);
+    if (!innerReturn) return null;
+    return resolveRowRoot(innerReturn, { identifiers: /* @__PURE__ */ new Map([[localName, { kind: "self" }]]) }, depth + 1);
+  }
+  function resolveFieldProjection(jsxPath, scope, depth) {
+    const tag = getTagName(jsxPath.node.openingElement);
+    if (isLowercaseTag(tag)) return { hostPath: jsxPath, scope };
+    if (depth >= MAX_PROJECTION_DEPTH) return null;
+    const fnPath = resolveComponentDefinition(tag, jsxPath);
+    if (!fnPath) return null;
+    const propCtx = buildCalleePropContext(fnPath);
+    if (!propCtx) return null;
+    const identifiers = /* @__PURE__ */ new Map();
+    for (const attr of jsxPath.node.openingElement.attributes) {
+      if (!t.isJSXAttribute(attr)) continue;
+      const localName = propCtx.propMap.get(getAttrName(attr));
+      if (!localName) continue;
+      const value = attr.value;
+      if (!t.isJSXExpressionContainer(value)) continue;
+      const expr = value.expression;
+      if (t.isJSXEmptyExpression(expr) || !t.isExpression(expr)) continue;
+      if (t.isIdentifier(expr)) {
+        const binding = scope.identifiers.get(expr.name);
+        if (binding?.kind === "self") {
+          identifiers.set(localName, { kind: "self" });
+          continue;
+        }
+      }
+      const verdict = classifyFieldExpr(expr, scope);
+      if (verdict?.kind === "static") {
+        identifiers.set(localName, { kind: "field", field: verdict.field });
+      }
+    }
+    if (identifiers.size === 0) return null;
+    const innerReturn = findReturnedJsxPath(fnPath);
+    if (!innerReturn) return null;
+    return resolveFieldProjection(innerReturn, { identifiers }, depth + 1);
+  }
+  function walkFieldsWithinRow(elementPath, scope) {
+    const childPaths = meaningfulChildPaths(elementPath);
+    const hasElementChild = childPaths.some((p) => p.isJSXElement());
+    if (hasElementChild) {
+      for (const childPath of childPaths) {
+        if (!childPath.isJSXElement()) continue;
+        handleStructuralChild(childPath, scope);
+      }
+      return;
+    }
+    if (childPaths.length === 0) return;
+    const exprChildren = childPaths.filter((p) => p.isJSXExpressionContainer());
+    if (childPaths.length === 1 && exprChildren.length === 1) {
+      stampPureLeaf(elementPath, exprChildren[0].node.expression, scope);
+      return;
+    }
+    if (childPaths.length > 1) {
+      stampLabelValueOrMixed(elementPath, childPaths, scope);
+    }
+  }
+  function handleStructuralChild(childPath, scope) {
+    const tag = getTagName(childPath.node.openingElement);
+    if (isLowercaseTag(tag)) {
+      walkFieldsWithinRow(childPath, scope);
+      return;
+    }
+    const projected = resolveFieldProjection(childPath, scope, 0);
+    if (!projected) return;
+    walkFieldsWithinRow(projected.hostPath, projected.scope);
+  }
+  function processSliceMap(callPath) {
+    const node = callPath.node;
+    const callee = node.callee;
+    if (!t.isMemberExpression(callee) || callee.computed) return;
+    if (!t.isIdentifier(callee.property, { name: "map" })) return;
+    if (!t.isExpression(callee.object)) return;
+    const source = resolveSliceSource(callee.object, callPath.scope, 0, false);
+    if (!source) return;
+    const [callback] = node.arguments;
+    if (!callback || !t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) return;
+    if (callback.params.length === 0) return;
+    const callbackPath = callPath.get("arguments.0");
+    if (Array.isArray(callbackPath)) return;
+    if (!callbackPath.isArrowFunctionExpression() && !callbackPath.isFunctionExpression()) return;
+    const initialScope = buildScopeFromParam(callback.params[0]);
+    if (!initialScope) return;
+    const returnedJsx = findReturnedJsxPath(callbackPath);
+    if (!returnedJsx) return;
+    const resolvedRoot = resolveRowRoot(returnedJsx, initialScope, 0);
+    if (!resolvedRoot) return;
+    const rowIdExpr = computeRowIdExpression(resolvedRoot.scope);
+    if (!rowIdExpr) return;
+    const { hostPath, scope } = resolvedRoot;
+    if (hasOwnAttr(hostPath, ATTR_ENTITY)) return;
+    addAttr(hostPath, ATTR_ENTITY, t.stringLiteral(source.entity));
+    addAttr(hostPath, ATTR_ROW, t.jsxExpressionContainer(rowIdExpr));
+    addAttr(hostPath, ATTR_COLLECTION_ORDER, t.stringLiteral(source.hasSort ? "derived" : "stable"));
+    walkFieldsWithinRow(hostPath, scope);
+  }
+  return {
+    name: "babel-plugin-collection-binding",
+    visitor: {
+      CallExpression(path, state) {
+        const filename = state.filename ?? "";
+        if (fileExclude.test(filename)) return;
+        processSliceMap(path);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  babelPluginCollectionBinding
+});