eddev 0.2.65 → 0.2.67-beta1

package/style/createStitches.js

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

package/style/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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);
 }) : (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": "es5" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "target": "ES2020" /* 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 @@
-declare type Observer<T> = (value: T) => void;
-declare type Disposer = () => void;
+type Observer<T> = (value: T) => void;
+type Disposer = () => void;
 export declare class Observable<T> {
     value: T;
     private _observers;

package/utils/Observable.js

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Observable = void 0;
-var Observable = /** @class */ (function () {
-    function Observable(value) {
+class Observable {
+    constructor(value) {
         this._observers = [];
         this.value = value;
     }
-    Observable.prototype.subscribe = function (observer) {
-        var _this = this;
+    subscribe(observer) {
         this._observers.push(observer);
         observer(this.value);
-        return function () { return _this.unsubscribe(observer); };
-    };
-    Observable.prototype.unsubscribe = function (observer) {
-        var index = this._observers.indexOf(observer);
+        return () => this.unsubscribe(observer);
+    }
+    unsubscribe(observer) {
+        const index = this._observers.indexOf(observer);
         if (index > -1) {
             this._observers.splice(index, 1);
         }
-    };
-    Observable.prototype.update = function (data) {
-        var _this = this;
+    }
+    update(data) {
         if (typeof data === "function") {
             // @ts-ignore
             this.value = data(this.value);
@@ -27,8 +25,7 @@ var Observable = /** @class */ (function () {
         else {
             this.value = data;
         }
-        this._observers.forEach(function (observer) { return observer(_this.value); });
-    };
-    return Observable;
-}());
+        this._observers.forEach((observer) => observer(this.value));
+    }
+}
 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;
-var git_repo_name_1 = __importDefault(require("git-repo-name"));
-var path_1 = __importDefault(require("path"));
+const git_repo_name_1 = __importDefault(require("git-repo-name"));
+const path_1 = __importDefault(require("path"));
 function getRepoName(dir) {
     if (process.env.VERCEL) {
         return {
@@ -14,7 +14,7 @@ function getRepoName(dir) {
         };
     }
     else {
-        var info = "";
+        let info = "";
         try {
             info = git_repo_name_1.default.sync(dir);
         }