@tamagui/generate-themes 1.89.25 → 1.89.27-1708112217600

package/dist/cjs/write-generate-themes.native.js

@@ -27,14 +27,154 @@ __export(write_generate_themes_exports, {
 });
 module.exports = __toCommonJS(write_generate_themes_exports);
 var import_path = require("path"), fs = __toESM(require("fs-extra"));
-async function writeGeneratedThemes(tamaguiDotDir, outPath, generatedOutput) {
-  if (!generatedOutput)
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
     return;
-  const { generated, state } = generatedOutput, tamaguiDotDirExists = await fs.pathExists(tamaguiDotDir), themeBuilderStatePath = (0, import_path.join)(tamaguiDotDir, "theme-builder.json");
-  process.env.DEBUG === "tamagui" && (console.info("Generated themes:", JSON.stringify(generatedOutput, null, 2)), console.info("Writing themes to", { outPath, themeBuilderStatePath })), await Promise.all([
-    fs.writeFile(outPath, generated),
-    state && tamaguiDotDirExists ? fs.writeFile(themeBuilderStatePath, JSON.stringify(state)) : null
-  ]);
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+function writeGeneratedThemes(tamaguiDotDir, outPath, generatedOutput) {
+  return _writeGeneratedThemes.apply(this, arguments);
+}
+function _writeGeneratedThemes() {
+  return _writeGeneratedThemes = _async_to_generator(function(tamaguiDotDir, outPath, generatedOutput) {
+    var generated, state, tamaguiDotDirExists, themeBuilderStatePath;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return generatedOutput ? (generated = generatedOutput.generated, state = generatedOutput.state, [
+            4,
+            fs.pathExists(tamaguiDotDir)
+          ]) : [
+            2
+          ];
+        case 1:
+          return tamaguiDotDirExists = _state.sent(), themeBuilderStatePath = (0, import_path.join)(tamaguiDotDir, "theme-builder.json"), process.env.DEBUG === "tamagui" && (console.info("Generated themes:", JSON.stringify(generatedOutput, null, 2)), console.info("Writing themes to", {
+            outPath,
+            themeBuilderStatePath
+          })), [
+            4,
+            Promise.all([
+              fs.writeFile(outPath, generated),
+              state && tamaguiDotDirExists ? fs.writeFile(themeBuilderStatePath, JSON.stringify(state)) : null
+            ])
+          ];
+        case 2:
+          return _state.sent(), [
+            2
+          ];
+      }
+    });
+  }), _writeGeneratedThemes.apply(this, arguments);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/write-generate-themes.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../src/write-generate-themes.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB,iBAErB,KAAoB;AAIpB,eAAsB,qBACpB,eACA,SACA,iBACA;AACA,MAAI,CAAC;AAAiB;AAEtB,QAAM,EAAE,WAAW,MAAM,IAAI,iBAEvB,sBAAsB,MAAM,GAAG,WAAW,aAAa,GACvD,4BAAwB,kBAAK,eAAe,oBAAoB;AAEtE,EAAI,QAAQ,IAAI,UAAU,cACxB,QAAQ,KAAK,qBAAqB,KAAK,UAAU,iBAAiB,MAAM,CAAC,CAAC,GAC1E,QAAQ,KAAK,qBAAqB,EAAE,SAAS,sBAAsB,CAAC,IAGtE,MAAM,QAAQ,IAAI;AAAA,IAChB,GAAG,UAAU,SAAS,SAAS;AAAA,IAC/B,SAAS,sBACL,GAAG,UAAU,uBAAuB,KAAK,UAAU,KAAK,CAAC,IACzD;AAAA,EACN,CAAC;AACH;",
-  "names": []
+  "sources": ["../../src/Users/n8/tamagui/packages/generate-themes/src/write-generate-themes.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kBAAqB,iBAErB,KAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIpB,SAAsBA,qBACpBC,eACAC,SACAC,iBAA2D;SAHvCH,sBAAAA,MAAAA,MAAAA,SAAAA;;SAAAA,wBAAAA;AAAAA,iCAAf,oBAAA,SACLC,eACAC,SACAC,iBAA2D;QAInDC,WAAWC,OAEbC,qBACAC;;;;AALN,iBAAKJ,mBAEGC,YAAqBD,gBAArBC,WAAWC,QAAUF,gBAAVE,OAES;;YAAMG,GAAGC,WAAWR,aAAAA;eAJ1B;;;;AAIhBK,uCAAsB,OAAA,KAAA,GACtBC,4BAAwBG,kBAAKT,eAAgB,oBAAA,GAE/CU,QAAQC,IAAIC,UAAU,cACxBC,QAAQC,KAAM,qBAAoBC,KAAKC,UAAUd,iBAAiB,MAAM,CAAA,CAAA,GACxEW,QAAQC,KAAM,qBAAoB;YAAEb;YAASK;UAAsB,CAAA,IAGrE;;YAAMW,QAAQC,IAAG;cACfX,GAAGY,UAAUlB,SAASE,SAAAA;cACtBC,SAASC,sBACLE,GAAGY,UAAUb,uBAAuBS,KAAKC,UAAUZ,KAAAA,CAAAA,IACnD;;;;AAJN,wBAAA,KAAA;;;;;EAMF,CAAA,GAvBsBL,sBAAAA,MAAAA,MAAAA,SAAAA;;",
+  "names": ["writeGeneratedThemes", "tamaguiDotDir", "outPath", "generatedOutput", "generated", "state", "tamaguiDotDirExists", "themeBuilderStatePath", "fs", "pathExists", "join", "process", "env", "DEBUG", "console", "info", "JSON", "stringify", "Promise", "all", "writeFile"]
 }

package/dist/esm/generate-themes.native.js

@@ -1,72 +1,294 @@
 import Module from "module";
 import { join } from "path";
-const ogRequire = Module.prototype.require;
-async function generateThemes(inputFile) {
-  const { unregister } = require("esbuild-register/dist/node").register({
-    hookIgnoreNodeModules: !1
-  }), inputFilePath = inputFile[0] === "." ? join(process.cwd(), inputFile) : inputFile;
-  purgeCache(inputFilePath);
-  let promise = null;
-  Module.prototype.require = function(id) {
-    const out = ogRequire.apply(this, arguments);
-    if (id === "@tamagui/theme-builder" && !promise) {
-      let resolve;
-      return promise = new Promise((res) => {
-        resolve = res;
-      }), createThemeIntercept(out, {
-        onComplete: (result) => {
-          resolve == null || resolve(result.themeBuilder);
-        }
-      });
-    }
-    return out;
-  };
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
-    const requiredThemes = require(inputFilePath), themes = requiredThemes.default || requiredThemes.themes, generatedThemes = generatedThemesToTypescript(themes);
-    let tm;
-    if (promise) {
-      let finished = !1;
-      promise.then(() => {
-        finished = !0;
-      }), tm = setTimeout(() => {
-        finished || console.warn(
-          "Warning: ThemeBuilder didn't finish after a couple seconds, did you forget to call .build()?"
-        );
-      }, 2e3);
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _iterable_to_array(iter) {
+  if (typeof Symbol < "u" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
     }
-    const themeBuilder = promise ? await promise : null;
-    return clearTimeout(tm), {
-      generated: generatedThemes,
-      state: themeBuilder == null ? void 0 : themeBuilder.state
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
     };
-  } catch (err) {
-    console.warn(` \u26A0\uFE0F Error running theme builder: ${err}`, err == null ? void 0 : err.stack);
-  } finally {
-    Module.prototype.require = ogRequire, unregister();
   }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+var ogRequire = Module.prototype.require;
+function generateThemes(inputFile) {
+  return _generateThemes.apply(this, arguments);
 }
-const dedupedTokens = /* @__PURE__ */ new Map();
+function _generateThemes() {
+  return _generateThemes = _async_to_generator(function(inputFile) {
+    var unregister, inputFilePath, promise, requiredThemes, themes, generatedThemes, tm, finished, themeBuilder, _tmp, err;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          unregister = require("esbuild-register/dist/node").register({
+            hookIgnoreNodeModules: !1
+          }).unregister, inputFilePath = inputFile[0] === "." ? join(process.cwd(), inputFile) : inputFile, purgeCache(inputFilePath), promise = null, Module.prototype.require = function(id) {
+            var out = ogRequire.apply(this, arguments);
+            if (id === "@tamagui/theme-builder" && !promise) {
+              var resolve;
+              return promise = new Promise(function(res) {
+                resolve = res;
+              }), createThemeIntercept(out, {
+                onComplete: function(result) {
+                  resolve == null || resolve(result.themeBuilder);
+                }
+              });
+            }
+            return out;
+          }, _state.label = 1;
+        case 1:
+          return _state.trys.push([
+            1,
+            5,
+            6,
+            7
+          ]), requiredThemes = require(inputFilePath), themes = requiredThemes.default || requiredThemes.themes, generatedThemes = generatedThemesToTypescript(themes), promise && (finished = !1, promise.then(function() {
+            finished = !0;
+          }), tm = setTimeout(function() {
+            finished || console.warn("Warning: ThemeBuilder didn't finish after a couple seconds, did you forget to call .build()?");
+          }, 2e3)), promise ? [
+            4,
+            promise
+          ] : [
+            3,
+            3
+          ];
+        case 2:
+          return _tmp = _state.sent(), [
+            3,
+            4
+          ];
+        case 3:
+          _tmp = null, _state.label = 4;
+        case 4:
+          return themeBuilder = _tmp, clearTimeout(tm), [
+            2,
+            {
+              generated: generatedThemes,
+              state: themeBuilder == null ? void 0 : themeBuilder.state
+            }
+          ];
+        case 5:
+          return err = _state.sent(), console.warn(" \u26A0\uFE0F Error running theme builder: ".concat(err), err == null ? void 0 : err.stack), [
+            3,
+            7
+          ];
+        case 6:
+          return Module.prototype.require = ogRequire, unregister(), [
+            7
+          ];
+        case 7:
+          return [
+            2
+          ];
+      }
+    });
+  }), _generateThemes.apply(this, arguments);
+}
+var dedupedTokens = /* @__PURE__ */ new Map();
 function generatedThemesToTypescript(themes) {
-  const dedupedThemes = /* @__PURE__ */ new Map(), dedupedThemeToNames = /* @__PURE__ */ new Map();
-  let i = 0;
-  for (const name in themes) {
+  var dedupedThemes = /* @__PURE__ */ new Map(), dedupedThemeToNames = /* @__PURE__ */ new Map(), i = 0;
+  for (var name in themes) {
     i++;
-    const theme = themes[name];
-    let j = 0;
-    for (const [key2, value] of Object.entries(theme)) {
-      i++;
-      const uniqueKey = `t${i}${j}`;
-      dedupedTokens.has(value) || dedupedTokens.set(value, uniqueKey);
+    var theme = themes[name], j = 0, _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+    try {
+      for (var _iterator = Object.entries(theme)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+        var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+        i++;
+        var uniqueKey = "t".concat(i).concat(j);
+        dedupedTokens.has(value) || dedupedTokens.set(value, uniqueKey);
+      }
+    } catch (err) {
+      _didIteratorError = !0, _iteratorError = err;
+    } finally {
+      try {
+        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      } finally {
+        if (_didIteratorError)
+          throw _iteratorError;
+      }
     }
-    const key = JSON.stringify(theme);
-    dedupedThemes.has(key) ? dedupedThemeToNames.set(key, [...dedupedThemeToNames.get(key), name]) : (dedupedThemes.set(key, theme), dedupedThemeToNames.set(key, [name]));
+    var key1 = JSON.stringify(theme);
+    dedupedThemes.has(key1) ? dedupedThemeToNames.set(key1, _to_consumable_array(dedupedThemeToNames.get(key1)).concat([
+      name
+    ])) : (dedupedThemes.set(key1, theme), dedupedThemeToNames.set(key1, [
+      name
+    ]));
   }
-  const baseKeys = Object.entries(themes.light || themes[Object.keys(themes)[0]]);
-  let out = `${`type Theme = {
-${baseKeys.map(([k]) => `  ${k}: string;
-`).join("")}
-}`}
-`;
+  var baseKeys = Object.entries(themes.light || themes[Object.keys(themes)[0]]), baseTypeString = `type Theme = {
+`.concat(baseKeys.map(function(param) {
+    var _param = _sliced_to_array(param, 1), k = _param[0];
+    return "  ".concat(k, `: string;
+`);
+  }).join(""), `
+}`), out = "".concat(baseTypeString, `
+`);
   out += `
 function t(a: [number, number][]) {
   let res: Record<string,string> = {}
@@ -77,27 +299,33 @@ function t(a: [number, number][]) {
 }
 `, out += `const vs = [
 `;
-  let index = 0;
-  const valueToIndex = {};
-  dedupedTokens.forEach((name, value) => {
-    valueToIndex[value] = index, index++, out += `  '${value}',
-`;
+  var index = 0, valueToIndex = {};
+  dedupedTokens.forEach(function(name2, value2) {
+    valueToIndex[value2] = index, index++, out += "  '".concat(value2, `',
+`);
   }), out += `]
 
 `;
-  const keys = baseKeys.map(([k]) => k);
+  var keys = baseKeys.map(function(param) {
+    var _param = _sliced_to_array(param, 1), k = _param[0];
+    return k;
+  });
   out += `const ks = [
-`, out += keys.map((k) => `'${k}'`).join(`,
+`, out += keys.map(function(k) {
+    return "'".concat(k, "'");
+  }).join(`,
 `), out += `]
 
 `;
-  let nameI = 0;
-  return dedupedThemes.forEach((theme) => {
+  var nameI = 0;
+  return dedupedThemes.forEach(function(theme2) {
     nameI++;
-    const key = JSON.stringify(theme), names = dedupedThemeToNames.get(key), name = `n${nameI}`, baseTheme = `const ${name} = ${objectToJsString(theme, keys, valueToIndex)}`;
+    var key2 = JSON.stringify(theme2), names = dedupedThemeToNames.get(key2), name2 = "n".concat(nameI), baseTheme = "const ".concat(name2, " = ").concat(objectToJsString(theme2, keys, valueToIndex));
     out += `
-${baseTheme}`;
-    const duplicateThemes = names.map((n) => `export const ${n} = ${name}`);
+`.concat(baseTheme);
+    var duplicateThemes = names.map(function(n) {
+      return "export const ".concat(n, " = ").concat(name2);
+    });
     out += `
 
 ` + duplicateThemes.join(`
@@ -105,20 +333,20 @@ ${baseTheme}`;
   }), out;
 }
 function objectToJsString(obj, keys, valueToIndex) {
-  let arrItems = [];
-  for (const key in obj) {
-    const ki = keys.indexOf(key), vi = valueToIndex[obj[key]];
-    arrItems.push(`[${ki}, ${vi}]`);
+  var arrItems = [];
+  for (var key in obj) {
+    var ki = keys.indexOf(key), vi = valueToIndex[obj[key]];
+    arrItems.push("[".concat(ki, ", ").concat(vi, "]"));
   }
-  return `t([${arrItems.join(",")}])`;
+  return "t([".concat(arrItems.join(","), "])");
 }
 function createThemeIntercept(createThemeExport, themeBuilderInterceptOpts) {
   return new Proxy(createThemeExport, {
-    get(target, key) {
-      const out = Reflect.get(target, key);
+    get: function(target, key) {
+      var out = Reflect.get(target, key);
       return key === "createThemeBuilder" ? new Proxy(out, {
-        apply(target2, thisArg, argArray) {
-          const builder = Reflect.apply(target2, thisArg, argArray);
+        apply: function(target2, thisArg, argArray) {
+          var builder = Reflect.apply(target2, thisArg, argArray);
           return themeBuilderIntercept(builder, themeBuilderInterceptOpts);
         }
       }) : out;
@@ -127,8 +355,8 @@ function createThemeIntercept(createThemeExport, themeBuilderInterceptOpts) {
 }
 function themeBuilderIntercept(themeBuilder, themeBuilderInterceptOpts) {
   return new Proxy(themeBuilder, {
-    get(target, key) {
-      const out = Reflect.get(target, key);
+    get: function(target, key) {
+      var out = Reflect.get(target, key);
       return key === "build" && themeBuilderInterceptOpts.onComplete({
         themeBuilder
       }), out;
@@ -143,8 +371,9 @@ function purgeCache(moduleName) {
   });
 }
 function searchCache(moduleName, callback) {
-  let mod = require.resolve(moduleName);
-  mod && (mod = require.cache[mod]) !== void 0 && function traverse(mod2, depth = 0) {
+  var mod = require.resolve(moduleName);
+  mod && (mod = require.cache[mod]) !== void 0 && function traverse(mod2) {
+    var depth = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
     depth > 10 || (mod2.children.forEach(function(child) {
       traverse(child, depth + 1);
     }), callback(mod2));