cardbuddy 0.6.0

package/dist/vendored/runtime/card-runtime.js

@@ -0,0 +1,289 @@
+/**
+ * 卡片交互运行时。
+ *
+ * 通过 Vue 的 provide/inject 下发给每个 RenderTree 节点（inject key: `cardRuntime`）。
+ *
+ * 与官方渲染模块 2130 里 `h` 给出的上下文对齐：customAction 脚本里的 `this`
+ * 拥有 `state` / `data` / `setData` / `setRootData` / `addEventListener` /
+ * `postMessage`，并挂载 `window.ynet.callJSAPI` 桩。
+ *
+ * 关键差异（用户选择了「支持交互」）：官方的 `setData` 是空函数，这里**真实生效**——
+ * 它把补丁合并进当前数据绑定，并自增 `revision` 强制整树重渲染。因此脚本里
+ * `this.setData({ activeTab: '2' })` 这类操作会真实改变后续渲染结果。
+ */
+import { reactive, watch, nextTick } from 'vue'
+
+/**
+ * 由 data 生成 state 的初始种子：浅拷贝顶层自有可枚举键（基础类型与引用）。
+ * 仅用于让「初始 state」镜像 data，避免脚本在赋值前读取 state.x 得到 undefined；
+ * 运行期 setData / `this.state.x = ...` 只改 stateScope，不会回写 rootScope。
+ */
+/**
+ * state 需要「结构性」地与 rootScope 彻底分离：不仅顶层键独立，嵌套对象/数组
+ * 也必须是各自的副本。否则（如 assetOverview 的 onReady 里 `this.state.listData.forEach(e =>
+ * e.ratio = ...)`）会顺着共享引用直接改到 rootScope 的持久化数据，进而被保存脏标记
+ * 误判为「已编辑」。data.json 是纯 JSON 数据，深拷贝安全。
+ */
+function deepCloneState(v) {
+  if (Array.isArray(v)) return v.map(deepCloneState)
+  if (v && typeof v === 'object') {
+    const out = {}
+    for (const k of Object.keys(v)) out[k] = deepCloneState(v[k])
+    return out
+  }
+  return v
+}
+function seedState(raw) {
+  return deepCloneState(raw || {})
+}
+
+/**
+ * 把一个日志实参格式化为可读字符串：字符串原样、基础类型 String()、
+ * 对象/数组 JSON 序列化（失败回退 String）。供事件面板展示 console.* 输出。
+ */
+function formatLogArg(a) {
+  if (a === null) return 'null'
+  if (a === undefined) return 'undefined'
+  const t = typeof a
+  if (t === 'string') return a
+  if (t === 'number' || t === 'boolean' || t === 'bigint') return String(a)
+  if (t === 'function') return '[Function ' + (a.name || 'anonymous') + ']'
+  try {
+    return JSON.stringify(a)
+  } catch {
+    return String(a)
+  }
+}
+
+/**
+ * 卡片事件执行产生的错误类型（事件代码 / 监听器）。
+ * 与绑定类错误（bind / vshow / render / refresh）的区别：
+ * - 绑定错误随每次渲染重新收集（渲染期产生，重渲染即重新计算）；
+ * - 事件错误由用户交互触发，必须跨渲染保留，直到切换卡片才清空。
+ */
+// 事件执行错误：用户交互/用户触发操作产生的错误，跨渲染保留（直到切卡才清空）。
+// 包括卡片内 customAction/listener，以及预览顶栏的保存/同步/刷新等操作失败。
+export const EVENT_ERROR_KINDS = ['customAction', 'listener', 'syncRemote', 'saveCard', 'refresh']
+
+export function createCardRuntime(rootScopeRaw, adapter) {
+  // rootScope：数据绑定（持久化），做成响应式，applyVars 取值时能建立细粒度依赖
+  let rootScope = reactive(rootScopeRaw || {})
+  // state：组件运行期本地状态，与 rootScope 完全分离。
+  // 关键修复：此前 this.state 被别名成 rootScope，导致运行时交互（如点击触发
+  // `this.state.x = ...`）直接污染持久化数据绑定，进而被 save 脏标记误判为「已编辑」。
+  // 现在 state 是独立对象，运行时状态写入只影响 state，绝不进入 rootScope/落盘；
+  // 渲染层经 makeRenderScope 按「state 优先于 data」合并，绑定仍可读到运行时状态。
+  let stateScope = reactive(seedState(rootScopeRaw))
+  // revision：强制整树重渲染的版本号（setData / 切换卡片时自增）
+  const revision = reactive({ value: 0 })
+  // errorRev：错误计数版本号。errors 本身是非响应式数组，调试面板状态栏
+  // 的 computed 依赖此值，保证错误变化后指示器刷新。注意：自增一律延迟到
+  // nextTick（渲染期之外的微任务），因为 pushError 可能在渲染函数内被调用
+  // （如 vshow 求值失败），若在渲染中读写 observable 会让 RenderTree 订阅
+  // errorRev 并自我触发，形成无限更新循环。
+  const errorRev = reactive({ value: 0 })
+  let bumpScheduled = false
+  // apiRev：接口调用流水版本号。apiCalls 本身是非响应式数组，调试面板
+  // 「接口调用」tab 的 computed 依赖此值，保证新调用/清空后实时刷新。
+  // pushApiCall 只在事件处理器中调用（postMessage / callJSAPI），不在
+  // 渲染函数内，直接自增安全，无需 nextTick 延迟。
+  const apiRev = reactive({ value: 0 })
+  // logRev：事件代码主动日志（console.*）流水版本号。与 apiRev 同理，仅在事件
+  // 处理器（用户交互/生命周期动作）中被 pushLog 自增，不在渲染函数内，直接自增安全。
+  const logRev = reactive({ value: 0 })
+  // 绑定错误的渲染期收集缓冲区：闭包内普通数组，不进入 Vue 响应式系统，
+  // 渲染中读写它不会建立任何依赖。渲染结束后由 commitBindingPass 一次性
+  // 替换进 rt.errors（绑定错误列表）。
+  let bindingBuffer = []
+
+  const rt = {
+    adapter,
+    /** 当前数据绑定（响应式，持久化） */
+    get rootScope() {
+      return rootScope
+    },
+    /** 组件运行期本地状态（响应式，独立于 rootScope，不落盘） */
+    get state() {
+      return stateScope
+    },
+    /**
+     * 切换卡片 / 绑定数据整体替换：**原地改写**现有响应式 rootScope，保持引用不变，
+     * 使 App.vue 的 `:scope="rt.rootScope"` 绑定、所有 `rt.rootScope` 读取方与画布
+     * 实时看到新数据。
+     *
+     * 早期实现把 rootScope 重赋成一个「新 reactive 对象」，导致 RenderTree 的 scope
+     * prop（在 App.vue 渲染时绑定、且 App.vue 不追踪该 getter 的内部闭包变量）仍指向
+     * 旧对象——于是「绑定数据 → 应用」保存后画布不刷新（典型复现：DebugPanel 绑定
+     * 数据 Raw 模式点「应用」）。见 App.vue 的 `:scope` 绑定与设计注释（rootScope
+     * 可经 setRootScope 整体替换而引用不变）。
+     */
+    setRootScope(raw) {
+      const src = raw || {}
+      // 清空并就地写入，保留 rootScope 这个响应式引用
+      for (const k of Object.keys(rootScope)) delete rootScope[k]
+      Object.assign(rootScope, src)
+      // state 重置为新基线的深拷贝（同样保持 stateScope 引用不变）
+      const seeded = seedState(src)
+      for (const k of Object.keys(stateScope)) delete stateScope[k]
+      Object.assign(stateScope, seeded)
+      this.markDirty()
+    },
+    /**
+     * 把运行态 state 重置为「当前绑定数据」的深拷贝。
+     * 用于：绑定数据（rootScope）发生变更后，让调试工作态回到最新基线——
+     * 调试交互只写 state、绝不触碰 rootScope，所以本重置不会清掉持久化数据，
+     * 只会把「运行态面板」里的临时调试值刷新为最新的绑定数据。
+     * 同样原地改写 stateScope，保持引用稳定（rt.state 经 getter 实时读取）。
+     */
+    reseedState() {
+      const seeded = seedState(rootScope)
+      for (const k of Object.keys(stateScope)) delete stateScope[k]
+      Object.assign(stateScope, seeded)
+      this.markDirty()
+    },
+    /** 重渲染版本号（RenderTree 在 render 中读取它建立依赖） */
+    get revision() {
+      return revision.value
+    },
+    /** 错误计数版本号（调试面板状态栏读取它建立响应式依赖） */
+    get errorRev() {
+      return errorRev.value
+    },
+    /** 接口调用流水版本号（调试面板「接口调用」tab 读取它建立响应式依赖） */
+    get apiRev() {
+      return apiRev.value
+    },
+    /** 事件主动日志（console.*）流水版本号（事件面板读取它建立响应式依赖） */
+    get logRev() {
+      return logRev.value
+    },
+
+    // 以下为非响应式簿记数据，调试面板直接读取
+    /** 绑定类错误（bind / vshow / render / refresh），每次渲染重新收集 */
+    errors: [],
+    /** 事件执行错误（customAction / listener），跨渲染保留 */
+    eventErrors: [],
+    /** 事件代码主动日志（console.log/warn/error 等），跨渲染保留，切卡清空 */
+    eventLogs: [],
+    apiCalls: [],
+    listeners: {},
+    markDirty() {
+      revision.value++
+    },
+    clearErrors() {
+      this.errors.length = 0
+      this.eventErrors.length = 0
+      this.eventLogs.length = 0
+      logRev.value++
+      this.scheduleErrorBump()
+    },
+    /** 只清绑定类错误（刷新/重建预览时用，事件错误应保留） */
+    clearBindingErrors() {
+      this.errors.length = 0
+      this.scheduleErrorBump()
+    },
+    clearApiCalls() {
+      this.apiCalls.length = 0
+      apiRev.value++
+    },
+    /**
+     * 捕获事件代码里的 console.* 主动日志。level 取 'log'|'info'|'warn'|'error'|'debug'，
+     * args 为原始实参数组，统一格式化为单行文本后入队（同时仍由调用方打到真实控制台）。
+     * 仅由用户事件/生命周期动作触发，直接自增 logRev 安全（不在渲染函数内）。
+     */
+    pushLog(level, args) {
+      const arr = args || []
+      const text = arr.map((a) => formatLogArg(a)).join(' ')
+      // 同时保留原始 args：面板据此做类型着色与 JSON 折叠渲染（text 仅作兜底）。
+      this.eventLogs.push({ level, text, args: arr, t: Date.now() })
+      if (this.eventLogs.length > 500) this.eventLogs.shift()
+      logRev.value++
+    },
+    /** 手动清空事件主动日志（事件面板「清空日志」按钮） */
+    clearEventLogs() {
+      this.eventLogs.length = 0
+      logRev.value++
+    },
+    pushError(kind, msg) {
+      // 事件执行错误单独存放，不随渲染重置
+      const list = EVENT_ERROR_KINDS.includes(kind) ? this.eventErrors : this.errors
+      list.push({ kind, msg, t: Date.now() })
+      if (list.length > 500) list.shift()
+      this.scheduleErrorBump()
+    },
+    /** 延迟自增 errorRev：确保不在渲染函数内读写 observable（防无限循环） */
+    scheduleErrorBump() {
+      if (bumpScheduled) return
+      bumpScheduled = true
+      nextTick(() => {
+        bumpScheduled = false
+        errorRev.value++
+      })
+    },
+    /** 渲染期绑定错误收集缓冲区（普通数组，非响应式） */
+    getBindingBuffer() {
+      return bindingBuffer
+    },
+    /** 根节点渲染开始时重置缓冲区，本轮渲染重新收集绑定错误 */
+    startBindingPass() {
+      bindingBuffer = []
+    },
+    /**
+     * 渲染结束后（mounted/updated 钩子）提交本轮绑定错误：
+     * 去重后整体替换 rt.errors。事件错误不受影响。
+     */
+    commitBindingPass() {
+      const seen = new Set()
+      const next = []
+      for (const e of bindingBuffer) {
+        if (seen.has(e.msg)) continue
+        seen.add(e.msg)
+        next.push(e)
+      }
+      this.errors.length = 0
+      for (const e of next) this.errors.push(e)
+      this.scheduleErrorBump()
+    },
+    pushApiCall(api, payload) {
+      this.apiCalls.push({ api, payload, t: Date.now() })
+      if (this.apiCalls.length > 500) this.apiCalls.shift()
+      apiRev.value++
+    },
+    addEventListener(name, fn) {
+      if (!this.listeners[name]) this.listeners[name] = []
+      this.listeners[name].push(fn)
+    },
+    /**
+     * 内部通讯：组件经 postMessage 通知「外部」（通常是根节点注册的监听器）
+     * 修改数据状态。对齐官方平台语义：派发时把 payload 包成 { data: payload }，
+     * 因此监听器统一以 `event.data` 读取内容（与卡片脚本里的
+     * `this.addEventListener('globalSet', e => self.$set(e.data.key, e.data.value))`
+     * 写法一致）。
+     */
+    postMessage(name, payload) {
+      const ls = this.listeners[name] || []
+      const event = { data: payload, type: name }
+      ls.forEach((fn) => {
+        try {
+          fn(event)
+        } catch (e) {
+          // 不再静默吞掉：监听器脚本出错时记录到调试面板，便于排查
+          this.pushError('listener', `${name}: ${e && e.message}`)
+        }
+      })
+      this.pushApiCall('postMessage:' + name, payload)
+    },
+  }
+
+  // 绑定数据（rootScope）一旦变更——就地编辑（绑定数据 tab 增删改）、换卡、
+  // Raw 应用、重置导入镜像等——即把运行态 state 重置为最新绑定数据的深拷贝，
+  // 使「运行态」面板回到干净基线。调试交互只写 state、不碰 rootScope，故不会
+  // 触发本 watch；watch 仅在绑定数据真正变化时回调（懒触发，不重渲染初始 seed）。
+  watch(
+    () => rootScope,
+    () => rt.reseedState(),
+    { deep: true }
+  )
+
+  return rt
+}

package/dist/vendored/runtime/clipboard-node.js

@@ -0,0 +1,83 @@
+/**
+ * 节点树剪贴板（编辑器内的复制/粘贴/副本）。
+ *
+ * 存储的是 schema 节点子树的深拷贝（纯数据，已剥离运行时 _schemaNode 引用），
+ * 粘贴/副本时再递归重写 componentId，避免与卡片内现有节点冲突。
+ *
+ * 设计要点：
+ *  - 用 Vue reactive 承载，便于结构树「粘贴」按钮实时反映剪贴板是否为空（disabled 态）；
+ *  - 实际插入 schema 时，会对存储的克隆再深拷贝一份并重新生成 id，保证重复粘贴互不影响；
+ *  - 记录来源卡片 id（sourceCardId），用于跨卡片粘贴时的来源标注与兼容性校验。
+ */
+
+import { reactive } from 'vue'
+import { genComponentId } from '@/runtime/toPreview.js'
+
+/** 剪贴板状态：node 为 null 表示空；sourceCardId 记录复制时所在卡片 id */
+export const nodeClipboard = reactive({ node: null, sourceCardId: null })
+
+/** 取出剪贴板当前节点（只读引用，勿就地改写） */
+export function getClipboardNode() {
+  return nodeClipboard.node
+}
+
+/** 取出剪贴板来源卡片 id（可能为 null，表示未知来源） */
+export function getClipboardSourceCardId() {
+  return nodeClipboard.sourceCardId
+}
+
+/** 写入剪贴板：深拷贝 schema 节点，剥离 _schemaNode 循环引用，并记录来源卡片 id */
+export function setClipboardNode(schemaNode, sourceCardId = null) {
+  if (!schemaNode) {
+    nodeClipboard.node = null
+    nodeClipboard.sourceCardId = null
+    return
+  }
+  const clone = JSON.parse(
+    JSON.stringify(schemaNode, (k, v) => (k === '_schemaNode' ? undefined : v)),
+  )
+  nodeClipboard.node = clone
+  nodeClipboard.sourceCardId = sourceCardId || null
+}
+
+export function clearClipboard() {
+  nodeClipboard.node = null
+  nodeClipboard.sourceCardId = null
+}
+
+/**
+ * 递归收集子树中所有节点的 className（去重），用于跨卡片粘贴前的兼容性校验。
+ * @param {Object} node schema 节点
+ * @param {Set<string>} [acc] 累加集合（内部递归用）
+ * @returns {string[]} 去重后的 className 列表
+ */
+export function collectClassNames(node, acc = new Set()) {
+  if (!node || typeof node !== 'object') return [...acc]
+  if (typeof node.className === 'string' && node.className) acc.add(node.className)
+  if (Array.isArray(node.slots)) {
+    for (const s of node.slots) {
+      if (s && Array.isArray(s.components)) {
+        for (const c of s.components) collectClassNames(c, acc)
+      }
+    }
+  }
+  return [...acc]
+}
+
+/**
+ * 递归重写子树内所有节点的 componentId，避免与卡片内现有节点冲突。
+ * @param {Object} node schema 节点（会被就地修改）
+ */
+export function regenerateComponentIds(node) {
+  if (!node || typeof node !== 'object') return
+  if (node.componentId != null && node.className != null) {
+    node.componentId = genComponentId(node.className)
+  }
+  if (Array.isArray(node.slots)) {
+    for (const s of node.slots) {
+      if (s && Array.isArray(s.components)) {
+        for (const c of s.components) regenerateComponentIds(c)
+      }
+    }
+  }
+}

package/dist/vendored/runtime/clipboard.js

@@ -0,0 +1,29 @@
+/**
+ * 复制文本到剪贴板。优先 navigator.clipboard，失败时降级到
+ * textarea + execCommand（兼容非安全上下文 / 旧浏览器）。
+ * @param {string} text 待复制文本
+ * @returns {Promise<boolean>} 是否复制成功
+ */
+export async function copyText(text) {
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      await navigator.clipboard.writeText(text)
+      return true
+    }
+  } catch (e) {
+    /* 降级到 execCommand */
+  }
+  try {
+    const ta = document.createElement('textarea')
+    ta.value = text
+    ta.style.position = 'fixed'
+    ta.style.opacity = '0'
+    document.body.appendChild(ta)
+    ta.select()
+    const ok = document.execCommand('copy')
+    document.body.removeChild(ta)
+    return ok
+  } catch (e) {
+    return false
+  }
+}

package/dist/vendored/runtime/evaluate.js

@@ -0,0 +1,152 @@
+/**
+ * 表达式求值 / 变量回填
+ *
+ * 移植自官方渲染模块 2130 里的 `d`(evalExpr)、`f`(setByPath)、`p`(applyVars)。
+ *
+ * 卡片 DSL 的数据绑定不是 `{{ }}` 模板，而是 **`$` 前缀的 JS 表达式**：
+ * 作用域里的 `foo` 会被改名成 `$foo` 注入，再用 `with(vars){ return (expr) }` 求值。
+ * 唯一的例外是 `$$`（作用域插槽的当前 item），它保持原名。
+ */
+
+/**
+ * 把作用域对象转成 `$` 前缀形式。
+ * @example { list: [], _index: 0 } -> { $list: [], $_index: 0 }
+ */
+export function toDollarScope(scope) {
+  const out = {};
+  const src = scope || {};
+  for (const k in src) {
+    if (k === '$$') out[k] = src[k];
+    else out['$' + k] = src[k];
+  }
+  return out;
+}
+
+/**
+ * 求值单个表达式。引用未定义变量时会抛 ReferenceError，由调用方决定如何降级。
+ * @param {string} expr 例如 "$rate > 0 ? '#f00' : '#0a0'"
+ * @param {Object} scope 原始作用域（不带 $ 前缀）
+ */
+export function evalExpr(expr, scope) {
+  const vars = toDollarScope(scope);
+  // 用 Proxy 包裹作用域：未定义的 `$` 变量解析为 undefined（而非抛 ReferenceError），
+  // 这样生产环境里 `$foo || 默认值` 这类兜底能正常生效。真正的语法错误仍会抛错并被上层捕获。
+  const proxy = new Proxy(vars, {
+    has(t, k) {
+      if (typeof k === 'string' && (k[0] === '$' || k === '$$')) return true
+      return k in t;
+    },
+    get(t, k) {
+      if (k in t) return t[k];
+      if (typeof k === 'string' && (k[0] === '$' || k === '$$')) return undefined;
+      return t[k];
+    },
+  });
+  // eslint-disable-next-line no-new-func
+  const fn = new Function('vars', `\n\t\twith(vars){\n\t\t\treturn (${expr})\n\t\t}\n\t`);
+  return fn(proxy);
+}
+
+/** 按点号路径写值。中间路径不存在时会抛错（与官方一致，交给上层 try/catch）。 */
+export function setByPath(obj, path, value) {
+  const seg = String(path).split('.');
+  const last = seg.pop();
+  let cur = obj;
+  for (let i = 0; i < seg.length; i++) cur = cur[seg[i]];
+  cur[last] = value;
+}
+
+/**
+ * 把 preview 对象里登记的变量表达式求值后回填。
+ *
+ * 注意：**逐项 try/catch**。某一项求值失败时该项保持 meta 默认值（而不是变成
+ * undefined）—— 这正是官方行为，也是 billListDialog 这类引用了未定义变量的卡
+ * 还能正常渲染的原因。
+ *
+ * @param {Object} previewObj 带 __vars__ 的 preview 产物
+ * @param {Object} scope 数据绑定
+ * @param {Object} [errors] 可选，收集失败信息用于调试面板
+ */
+export function applyVars(previewObj = {}, scope = {}, errors) {
+  const out = JSON.parse(JSON.stringify(previewObj || {}));
+  const vars = previewObj && previewObj.__vars__;
+  if (vars) {
+    for (const path in vars) {
+      try {
+        setByPath(out, path, evalExpr(vars[path], scope));
+      } catch (e) {
+        if (errors)
+          errors.push({
+            kind: 'bind',
+            msg: `${path} <- ${vars[path]}: ${e && e.message}`,
+            path,
+            expr: vars[path],
+          });
+      }
+    }
+  }
+  delete out.__vars__;
+  return out;
+}
+
+/**
+ * 构造作用域插槽的子作用域。
+ * 与官方一致：外层作用域 + item 对象**展开** + `$$`(整个 item) + `_index`(索引)。
+ * 所以列表项内部既能写 `$fieldName`，也能写 `$$` 和 `$_index`。
+ */
+export function makeSlotScope(parentScope, item, index) {
+  return Object.assign(
+    {},
+    parentScope,
+    (typeof item === 'object' && item) || {},
+    { $$: item, _index: index },
+  );
+}
+
+/**
+ * 构造「渲染作用域」：base（局部作用域）优先于 state（rt.state 运行期写入）合并后的只读视图。
+ *
+ * 关键语义（修复列表项字段被全局字段遮蔽的 bug）：
+ *  - 列表项（ListLayout/GridLayout 的插槽子节点）的 base = itemScope（含 item.title 等），
+ *    必须优先于卡片全局的 rt.state（deep-copy 了整份卡片数据，也含顶层 title）——
+ *    否则列表项内 `$title` 会取到「卡片外层 greeting」而非「列表项自身 title」。
+ *  - 根节点 base 取 rt.state（见 App.vue 的 :scope="rt.state"），而 rt.state 本身已是
+ *    rootScope 的运行期副本，故根层级「运行期写入优先生效」语义不变（state 即 base）。
+ *  - state 与 base 均只读，state 写入经 runCustomAction 的 set 陷阱落 rt.state，
+ *    绝不反向污染 rootScope（持久化数据绑定）—— 修复「点击交互触发 setData 把卡片误判为已编辑」。
+ *
+ * 用 Proxy + ownKeys/getOwnPropertyDescriptor 陷阱，保证 evalExpr 内部的
+ * toDollarScope 用 `for...in` 枚举、以及 `scope[k]` 取值都能正确遍历合并后的键，
+ * 且读取底层 reactive（state / rootScope）以建立响应式依赖。
+ *
+ * 从 RenderTree.vue 提升至此，供回归测试直接测真实实现（L0-7 渲染作用域语义）。
+ */
+export function makeRenderScope(stateScope, baseScope) {
+  return new Proxy(
+    {},
+    {
+      get(_, k) {
+        if (k in baseScope) return baseScope[k]
+        return stateScope[k]
+      },
+      has(_, k) {
+        return k in baseScope || k in stateScope
+      },
+      ownKeys() {
+        const seen = new Set()
+        for (const k of Object.keys(baseScope)) seen.add(k)
+        for (const k of Object.keys(stateScope)) seen.add(k)
+        return [...seen]
+      },
+      getOwnPropertyDescriptor(_, k) {
+        if (k in baseScope)
+          return { enumerable: true, configurable: true, value: baseScope[k] }
+        if (k in stateScope)
+          return { enumerable: true, configurable: true, value: stateScope[k] }
+        return undefined
+      },
+    }
+  )
+}
+
+export default applyVars;