eddev 0.2.67-beta1 → 0.3.0-beta1

package/style/createStitches.js

@@ -1,8 +1,19 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStitches = exports.parseResponsiveTokens = exports.getResponsiveObjectStyles = exports.parseResponsiveObject = exports.parseBreakpoints = void 0;
-const react_1 = require("@stitches/react");
-const typeKeyMap = {
+var react_1 = require("@stitches/react");
+var typeKeyMap = {
     fontSize: "fontSizes",
     fontFamily: "fonts",
     lineHeight: "lineHeights",
@@ -10,29 +21,29 @@ const typeKeyMap = {
     fontWeight: "fontWeights",
 };
 function parseBreakpoints(names, medias) {
-    const breakpoints = [];
+    var breakpoints = [];
     // Add an initial breakpoint
     breakpoints.push({ key: "initial", min: "0px", max: null });
     // Parse each breakpoint
-    for (const key in medias) {
+    for (var key in medias) {
         if (!names.includes(key))
             continue;
-        const media = medias[key];
-        const minMatch = media.match(/min-width: ([0-9]+[a-z]+)/);
-        const maxMatch = media.match(/max-width: ([0-9]+[a-z]+)/);
+        var media = medias[key];
+        var minMatch = media.match(/min-width: ([0-9]+[a-z]+)/);
+        var maxMatch = media.match(/max-width: ([0-9]+[a-z]+)/);
         if (!minMatch && !maxMatch)
             continue;
         breakpoints.push({
-            key,
+            key: key,
             min: minMatch ? minMatch[1] : null,
             max: maxMatch ? maxMatch[1] : null,
         });
     }
     // Ensure each breakpoint has a min/max value (except for first and last)
-    for (let i = 0; i < breakpoints.length; i++) {
-        const bp = breakpoints[i];
-        const prev = breakpoints[i - 1];
-        const next = breakpoints[i + 1];
+    for (var i = 0; i < breakpoints.length; i++) {
+        var bp = breakpoints[i];
+        var prev = breakpoints[i - 1];
+        var next = breakpoints[i + 1];
         if (bp.min === null && prev && prev.max) {
             bp.min = prev.max;
         }
@@ -43,13 +54,13 @@ function parseBreakpoints(names, medias) {
     return breakpoints;
 }
 exports.parseBreakpoints = parseBreakpoints;
-const unitless = (value) => parseFloat(value);
+var unitless = function (value) { return parseFloat(value); };
 function parseTypography(theme, breakpoints, typography) {
-    const globals = {};
-    const typeVariants = {};
-    breakpoints.forEach((bp) => (globals["@" + bp.key] = {}));
+    var globals = {};
+    var typeVariants = {};
+    breakpoints.forEach(function (bp) { return (globals["@" + bp.key] = {}); });
     globals["@editor"] = {};
-    const resolveValue = (scale, value) => {
+    var resolveValue = function (scale, value) {
         if (typeof value === "string" && value.match(/^\$[a-z0-9\-\_]+$/)) {
             // Single scale
             return theme[scale][value.replace("$", "")];
@@ -58,7 +69,7 @@ function parseTypography(theme, breakpoints, typography) {
             return value;
         }
     };
-    const resolveThemeVar = (scale, value) => {
+    var resolveThemeVar = function (scale, value) {
         if (typeof value === "string" && value.match(/^\$[a-z0-9\-\_]+$/)) {
             // Single scale
             return "$" + scale + value;
@@ -67,25 +78,25 @@ function parseTypography(theme, breakpoints, typography) {
             return value;
         }
     };
-    for (const name in typography) {
-        const style = typography[name];
-        const variant = {};
-        typeVariants[name] = variant;
-        for (const key in style) {
-            const value = style[key];
-            const varName = `--type-${name}-${key}`;
-            variant[key] = `var(${varName})`;
-            const tokenPrefix = typeKeyMap[key];
+    for (var name_1 in typography) {
+        var style = typography[name_1];
+        var variant = {};
+        typeVariants[name_1] = variant;
+        for (var key in style) {
+            var value = style[key];
+            var varName = "--type-".concat(name_1, "-").concat(key);
+            variant[key] = "var(".concat(varName, ")");
+            var tokenPrefix = typeKeyMap[key];
             if (typeof value === "string" || typeof value === "number") {
                 // A simple string or number value is used
                 globals["@initial"][varName] = resolveThemeVar(tokenPrefix, value);
             }
             else if (value && typeof value === "object") {
                 // A responsive object value
-                const unit = key === "lineHeight" ? "%" : "px";
-                const [tokenGlobals, initial] = getResponsiveObjectStyles(breakpoints, value, varName, unit);
-                for (const key in tokenGlobals) {
-                    globals[key] = { ...globals[key], ...tokenGlobals[key] };
+                var unit = key === "lineHeight" ? "%" : "px";
+                var _a = getResponsiveObjectStyles(breakpoints, value, varName, unit), tokenGlobals = _a[0], initial = _a[1];
+                for (var key_1 in tokenGlobals) {
+                    globals[key_1] = __assign(__assign({}, globals[key_1]), tokenGlobals[key_1]);
                 }
                 // const entries = Object.entries(value)
                 // entries.forEach(([bpName, responsiveValue], i) => {
@@ -113,11 +124,11 @@ function parseTypography(theme, breakpoints, typography) {
         }
     }
     // debugger
-    return { globalTypography: globals, typeVariants };
+    return { globalTypography: globals, typeVariants: typeVariants };
 }
 function parseGrid(theme, media, grid) {
-    const globalGrid = {};
-    const resolveThemeVar = (scale, value) => {
+    var globalGrid = {};
+    var resolveThemeVar = function (scale, value) {
         if (typeof value === "string" && value.match(/^\$[a-z0-9\-\_]+$/)) {
             // Single scale
             return "$" + scale + value;
@@ -126,24 +137,22 @@ function parseGrid(theme, media, grid) {
             return value;
         }
     };
-    for (let [bpName, breakpoint] of Object.entries(grid.breakpoints)) {
+    for (var _i = 0, _a = Object.entries(grid.breakpoints); _i < _a.length; _i++) {
+        var _b = _a[_i], bpName = _b[0], breakpoint = _b[1];
         globalGrid[bpName] = {
             "--grid-columns": grid.columns,
             "--grid-outer-width": breakpoint.container,
-            "--grid-inner-width": `calc(${breakpoint.container} - ${resolveThemeVar("spaces", breakpoint.margin)} * 2)`,
+            "--grid-inner-width": "calc(".concat(breakpoint.container, " - ").concat(resolveThemeVar("spaces", breakpoint.margin), " * 2)"),
             "--grid-gutter": breakpoint.gutter,
             "--grid-margin": breakpoint.margin,
-            "--grid-col-width": `calc((var(--grid-inner-width) - (${grid.columns - 1} * var(--grid-gutter))) / ${grid.columns})`,
+            "--grid-col-width": "calc((var(--grid-inner-width) - (".concat(grid.columns - 1, " * var(--grid-gutter))) / ").concat(grid.columns, ")"),
         };
     }
-    return { gridVariants: {}, globalGrid };
+    return { gridVariants: {}, globalGrid: globalGrid };
 }
 function parseResponsiveValue(val) {
     if (Array.isArray(val)) {
-        return {
-            ...parseResponsiveValue(val[0]),
-            lerpStart: true,
-        };
+        return __assign(__assign({}, parseResponsiveValue(val[0])), { lerpStart: true });
     }
     else if (typeof val === "string") {
         if (val.match(/^x[0-9\.]+$/)) {
@@ -189,21 +198,23 @@ function parseResponsiveValue(val) {
 }
 function parseResponsiveObject(breakpoints, object) {
     // Breakpoint hash
-    const breakpointHash = {};
-    for (let bp of breakpoints) {
+    var breakpointHash = {};
+    for (var _i = 0, breakpoints_1 = breakpoints; _i < breakpoints_1.length; _i++) {
+        var bp = breakpoints_1[_i];
         breakpointHash[bp.key] = {
             min: bp.min ? parseFloat(bp.min) : null,
             max: bp.max ? parseFloat(bp.max) : null,
         };
     }
-    const result = [];
-    let lerpStart = "initial";
-    let lastDefined = "initial";
-    let concreteValues = {};
-    for (let bp of breakpoints) {
-        const value = parseResponsiveValue(object["@" + bp.key]);
-        const defined = value.type !== "undefined";
-        let base = !defined || value.type === "multiplier" ? lastDefined : bp.key;
+    var result = [];
+    var lerpStart = "initial";
+    var lastDefined = "initial";
+    var concreteValues = {};
+    for (var _a = 0, breakpoints_2 = breakpoints; _a < breakpoints_2.length; _a++) {
+        var bp = breakpoints_2[_a];
+        var value = parseResponsiveValue(object["@" + bp.key]);
+        var defined = value.type !== "undefined";
+        var base = !defined || value.type === "multiplier" ? lastDefined : bp.key;
         lerpStart = value.lerpStart ? bp.key : lerpStart && !defined ? lerpStart : null;
         if (value.type === "px" || value.type === "number") {
             concreteValues[bp.key] = value.value;
@@ -214,13 +225,7 @@ function parseResponsiveObject(breakpoints, object) {
         else if (value.type === "percent") {
             concreteValues[bp.key] = value.value;
         }
-        result.push({
-            ...value,
-            defined: defined,
-            breakpoint: bp.key,
-            lastBreakpoint: lastDefined,
-            baseBreakpoint: base,
-            lerping: lerpStart
+        result.push(__assign(__assign({}, value), { defined: defined, breakpoint: bp.key, lastBreakpoint: lastDefined, baseBreakpoint: base, lerping: lerpStart
                 ? {
                     fromBP: lerpStart,
                     toBP: null,
@@ -229,91 +234,90 @@ function parseResponsiveObject(breakpoints, object) {
                     minValue: 0,
                     maxValue: 0,
                 }
-                : undefined,
-            concreteValue: concreteValues[bp.key],
-        });
+                : undefined, concreteValue: concreteValues[bp.key] }));
         if (defined) {
             lastDefined = bp.key;
         }
     }
-    let nextBreakpoints = [];
-    let lastBreakpoint = null;
-    for (let i = breakpoints.length - 1; i >= 0; i--) {
-        const bp = breakpoints[i];
+    var nextBreakpoints = [];
+    var lastBreakpoint = null;
+    for (var i = breakpoints.length - 1; i >= 0; i--) {
+        var bp = breakpoints[i];
         nextBreakpoints[i] = lastBreakpoint;
         if (result[i].defined) {
             lastBreakpoint = bp.key;
         }
     }
-    result.forEach((item, i) => {
+    result.forEach(function (item, i) {
         if (item.lerping) {
             item.lerping.toBP = nextBreakpoints[i];
         }
     });
-    result.forEach((item, i) => {
-        const lerp = item.lerping;
+    result.forEach(function (item, i) {
+        var lerp = item.lerping;
         if (lerp) {
-            const fromBP = lerp.fromBP ? breakpointHash[lerp.fromBP] : null;
-            const toBP = lerp.toBP ? breakpointHash[lerp.toBP] : null;
+            var fromBP = lerp.fromBP ? breakpointHash[lerp.fromBP] : null;
+            var toBP = lerp.toBP ? breakpointHash[lerp.toBP] : null;
             if (!fromBP || fromBP.min === null) {
-                throw new Error(`Cannot create responsive style for first breakpoint`);
+                throw new Error("Cannot create responsive style for first breakpoint");
             }
             if (!toBP || toBP.min === null) {
-                throw new Error(`Cannot create responsive style for last breakpoint`);
+                throw new Error("Cannot create responsive style for last breakpoint");
             }
             lerp.minMedia = fromBP.min;
             lerp.maxMedia = toBP.min;
             lerp.minValue = item.concreteValue;
-            lerp.maxValue = result.find((o) => o.breakpoint === lerp.toBP).concreteValue;
+            lerp.maxValue = result.find(function (o) { return o.breakpoint === lerp.toBP; }).concreteValue;
         }
     });
     return result;
 }
 exports.parseResponsiveObject = parseResponsiveObject;
-function getResponsiveObjectStyles(breakpoints, object, varName, unit = "px") {
+function getResponsiveObjectStyles(breakpoints, object, varName, unit) {
+    var _a, _b, _c;
+    var _d;
+    if (unit === void 0) { unit = "px"; }
     // Prescale object
-    object = { ...object };
-    const parsed = parseResponsiveObject(breakpoints, object);
-    const globals = {};
-    for (let atom of parsed) {
+    object = __assign({}, object);
+    var parsed = parseResponsiveObject(breakpoints, object);
+    var globals = {};
+    for (var _i = 0, parsed_1 = parsed; _i < parsed_1.length; _i++) {
+        var atom = parsed_1[_i];
         if (atom.lerpStart && atom.lerping) {
-            const lerp = atom.lerping;
-            globals["@" + atom.breakpoint] = {
-                [varName]: `calc(${lerp.minValue}${unit} + (100vw - ${lerp.minMedia}${unit}) / (${lerp.maxMedia} - ${lerp.minMedia}) * (${lerp.maxValue} - ${lerp.minValue}))`,
-            };
+            var lerp = atom.lerping;
+            globals["@" + atom.breakpoint] = (_a = {},
+                _a[varName] = "calc(".concat(lerp.minValue).concat(unit, " + (100vw - ").concat(lerp.minMedia).concat(unit, ") / (").concat(lerp.maxMedia, " - ").concat(lerp.minMedia, ") * (").concat(lerp.maxValue, " - ").concat(lerp.minValue, "))"),
+                _a);
         }
         else if (atom.concreteValue) {
-            globals["@" + atom.breakpoint] = {
-                [varName]: atom.concreteValue + unit,
-            };
+            globals["@" + atom.breakpoint] = (_b = {},
+                _b[varName] = atom.concreteValue + unit,
+                _b);
         }
         else if (atom.defined) {
-            globals["@" + atom.breakpoint] = {
-                [varName]: atom.value,
-            };
+            globals["@" + atom.breakpoint] = (_c = {},
+                _c[varName] = atom.value,
+                _c);
         }
     }
-    return [globals, globals["@initial"]?.[varName]];
+    return [globals, (_d = globals["@initial"]) === null || _d === void 0 ? void 0 : _d[varName]];
 }
 exports.getResponsiveObjectStyles = getResponsiveObjectStyles;
 // parseResponsiveTokens({'@initial': blah, '@desktop': blah}, breakpoints, )
 function parseResponsiveTokens(theme, breakpoints) {
-    const globalResponsive = {
+    var globalResponsive = {
         "@initial": {},
     };
-    const initialResponsive = {};
-    for (const scale in theme) {
-        const initials = {};
+    var initialResponsive = {};
+    for (var scale in theme) {
+        var initials = {};
         initialResponsive[scale] = initials;
-        for (const key in theme[scale]) {
-            const val = theme[scale][key];
+        for (var key in theme[scale]) {
+            var val = theme[scale][key];
             if (val && typeof val === "object") {
-                const [tokenGlobals, initial] = getResponsiveObjectStyles(breakpoints, val, "--" + scale + "-" + key);
-                for (const bp in tokenGlobals) {
-                    globalResponsive[bp] = {
-                        ...globalResponsive[bp],
-                        ...tokenGlobals[bp],
-                    };
+                var _a = getResponsiveObjectStyles(breakpoints, val, "--" + scale + "-" + key), tokenGlobals = _a[0], initial = _a[1];
+                for (var bp in tokenGlobals) {
+                    globalResponsive[bp] = __assign(__assign({}, globalResponsive[bp]), tokenGlobals[bp]);
                 }
                 initials[key] = initial;
             }
@@ -322,80 +326,60 @@ function parseResponsiveTokens(theme, breakpoints) {
             }
         }
     }
-    return { initialResponsive, globalResponsive };
+    return { initialResponsive: initialResponsive, globalResponsive: globalResponsive };
 }
 exports.parseResponsiveTokens = parseResponsiveTokens;
 function createStitches(config) {
-    const breakpoints = parseBreakpoints(config.breakpoints, config.media);
-    const { typeVariants, globalTypography } = parseTypography(config.theme, breakpoints, config.typography);
-    const { gridVariants, globalGrid } = parseGrid(config.theme, config.media, config.grid);
-    const { initialResponsive, globalResponsive } = parseResponsiveTokens(config.responsive, breakpoints);
-    const stitches = (0, react_1.createStitches)({
+    var breakpoints = parseBreakpoints(config.breakpoints, config.media);
+    var _a = parseTypography(config.theme, breakpoints, config.typography), typeVariants = _a.typeVariants, globalTypography = _a.globalTypography;
+    var _b = parseGrid(config.theme, config.media, config.grid), gridVariants = _b.gridVariants, globalGrid = _b.globalGrid;
+    var _c = parseResponsiveTokens(config.responsive, breakpoints), initialResponsive = _c.initialResponsive, globalResponsive = _c.globalResponsive;
+    var stitches = (0, react_1.createStitches)({
         // prefix: config.prefix,
-        media: {
-            initial: "",
-            ...config.media,
-        },
-        theme: { ...config.theme, ...initialResponsive },
+        media: __assign({ initial: "" }, config.media),
+        theme: __assign(__assign({}, config.theme), initialResponsive),
         themeMap: config.themeMap,
-        utils: {
-            ...(config.utils || {}),
-            typography: (key) => typeVariants[key],
-            m: (value) => ({
+        utils: __assign(__assign({}, (config.utils || {})), { typography: function (key) { return typeVariants[key]; }, m: function (value) { return ({
                 margin: value,
-            }),
-            mt: (value) => ({
+            }); }, mt: function (value) { return ({
                 marginTop: value,
-            }),
-            mr: (value) => ({
+            }); }, mr: function (value) { return ({
                 marginRight: value,
-            }),
-            mb: (value) => ({
+            }); }, mb: function (value) { return ({
                 marginBottom: value,
-            }),
-            ml: (value) => ({
+            }); }, ml: function (value) { return ({
                 marginLeft: value,
-            }),
-            mx: (value) => ({
+            }); }, mx: function (value) { return ({
                 marginLeft: value,
                 marginRight: value,
-            }),
-            my: (value) => ({
+            }); }, my: function (value) { return ({
                 marginTop: value,
                 marginBottom: value,
-            }),
-            p: (value) => ({
+            }); }, p: function (value) { return ({
                 padding: value,
-            }),
-            pt: (value) => ({
+            }); }, pt: function (value) { return ({
                 paddingTop: value,
-            }),
-            pr: (value) => ({
+            }); }, pr: function (value) { return ({
                 paddingRight: value,
-            }),
-            pb: (value) => ({
+            }); }, pb: function (value) { return ({
                 paddingBottom: value,
-            }),
-            pl: (value) => ({
+            }); }, pl: function (value) { return ({
                 paddingLeft: value,
-            }),
-            px: (value) => ({
+            }); }, px: function (value) { return ({
                 paddingLeft: value,
                 paddingRight: value,
-            }),
-            py: (value) => ({
+            }); }, py: function (value) { return ({
                 paddingTop: value,
                 paddingBottom: value,
-            }),
-            cols: (value) => ({
-                gridColumn: `auto / span ${value}`,
+            }); }, cols: function (value) { return ({
+                gridColumn: "auto / span ".concat(value),
                 "--grid-columns": value,
-            }),
-        },
+            }); } }),
     });
     // Typography globals
-    const typeGlobals = {};
-    Object.entries(globalTypography).forEach(([key, styles]) => {
+    var typeGlobals = {};
+    Object.entries(globalTypography).forEach(function (_a) {
+        var key = _a[0], styles = _a[1];
         if (key === "@initial") {
             typeGlobals[":root"] = styles;
         }
@@ -408,8 +392,9 @@ function createStitches(config) {
     });
     stitches.globalCss(typeGlobals)();
     // Grid globals
-    const gridGlobals = {};
-    Object.entries(globalGrid).forEach(([key, styles]) => {
+    var gridGlobals = {};
+    Object.entries(globalGrid).forEach(function (_a) {
+        var key = _a[0], styles = _a[1];
         if (key === "@initial") {
             gridGlobals[":root"] = styles;
         }
@@ -421,8 +406,9 @@ function createStitches(config) {
         }
     });
     stitches.globalCss(gridGlobals)();
-    const responsiveGlobals = {};
-    Object.entries(globalResponsive).forEach(([key, styles]) => {
+    var responsiveGlobals = {};
+    Object.entries(globalResponsive).forEach(function (_a) {
+        var key = _a[0], styles = _a[1];
         if (key === "@initial") {
             responsiveGlobals[":root"] = styles;
         }
@@ -434,15 +420,7 @@ function createStitches(config) {
         }
     });
     stitches.globalCss(responsiveGlobals)();
-    const responsiveTokens = {};
-    return {
-        ...stitches,
-        originalConfig: config,
-        breakpoints,
-        typeVariants,
-        gridVariants,
-        responsiveTokens,
-        responsiveGlobals,
-    };
+    var responsiveTokens = {};
+    return __assign(__assign({}, stitches), { originalConfig: config, breakpoints: breakpoints, typeVariants: typeVariants, gridVariants: gridVariants, responsiveTokens: responsiveTokens, responsiveGlobals: responsiveGlobals });
 }
 exports.createStitches = createStitches;

package/style/index.js

@@ -1,11 +1,7 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/tsconfig.json

@@ -11,7 +11,7 @@
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
     /* Language and Environment */
-    "target": "ES2020" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "target": "es5" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
     // "types": ["./src/types.d.ts"],
     "lib": [
       "DOM",

package/utils/Observable.d.ts

@@ -1,5 +1,5 @@
-type Observer<T> = (value: T) => void;
-type Disposer = () => void;
+declare type Observer<T> = (value: T) => void;
+declare type Disposer = () => void;
 export declare class Observable<T> {
     value: T;
     private _observers;

package/utils/Observable.js

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observable = void 0;
-class Observable {
-    constructor(value) {
+var Observable = /** @class */ (function () {
+    function Observable(value) {
         this._observers = [];
         this.value = value;
     }
-    subscribe(observer) {
+    Observable.prototype.subscribe = function (observer) {
+        var _this = this;
         this._observers.push(observer);
         observer(this.value);
-        return () => this.unsubscribe(observer);
-    }
-    unsubscribe(observer) {
-        const index = this._observers.indexOf(observer);
+        return function () { return _this.unsubscribe(observer); };
+    };
+    Observable.prototype.unsubscribe = function (observer) {
+        var index = this._observers.indexOf(observer);
         if (index > -1) {
             this._observers.splice(index, 1);
         }
-    }
-    update(data) {
+    };
+    Observable.prototype.update = function (data) {
+        var _this = this;
         if (typeof data === "function") {
             // @ts-ignore
             this.value = data(this.value);
@@ -25,7 +27,8 @@ class Observable {
         else {
             this.value = data;
         }
-        this._observers.forEach((observer) => observer(this.value));
-    }
-}
+        this._observers.forEach(function (observer) { return observer(_this.value); });
+    };
+    return Observable;
+}());
 exports.Observable = Observable;

package/utils/getRepoName.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRepoName = void 0;
-const git_repo_name_1 = __importDefault(require("git-repo-name"));
-const path_1 = __importDefault(require("path"));
+var git_repo_name_1 = __importDefault(require("git-repo-name"));
+var path_1 = __importDefault(require("path"));
 function getRepoName(dir) {
     if (process.env.VERCEL) {
         return {
@@ -14,7 +14,7 @@ function getRepoName(dir) {
         };
     }
     else {
-        let info = "";
+        var info = "";
         try {
             info = git_repo_name_1.default.sync(dir);
         }