@tolgee/cli 2.8.4 → 2.10.0

package/dist/extractor/parser/tree/getValue.js

@@ -2,7 +2,7 @@ import { parseGeneral } from './parseGeneral.js';
 export function getValue(context) {
     const token = context.tokens.current();
     const line = context.getCurrentLine();
-    switch (token?.customType) {
+    switch (token === null || token === void 0 ? void 0 : token.customType) {
         case 'string':
         case 'primitive.null':
             return { type: 'primitive', line, value: token.token };

package/dist/extractor/parser/tree/parseTag.js

@@ -8,7 +8,7 @@ export const parseTag = (context) => {
     const props = extractProps(context);
     let child;
     const currentTag = tokens.current();
-    if (currentTag?.customType === 'tag.regular.end') {
+    if ((currentTag === null || currentTag === void 0 ? void 0 : currentTag.customType) === 'tag.regular.end') {
         tokens.next();
         // it's not self-closing and there are children
         const extracted = parseGeneral(context, {

package/dist/extractor/parserNgx/ParserNgx.js

@@ -19,9 +19,7 @@ export const ngxMergers = pipeMachines([
 export const ParserNgx = () => {
     return Parser({
         mappers: ngxMappers,
-        blocks: {
-            ...DEFAULT_BLOCKS,
-        },
+        blocks: Object.assign({}, DEFAULT_BLOCKS),
         rules: [componentWithT, translatePipe, translateFunction],
         merger: ngxMergers,
         treeTransform: ngxTreeTransform,

package/dist/extractor/parserNgx/ngxMapper.js

@@ -1,6 +1,7 @@
 export const ngxMapper = (token) => {
+    var _a;
     // custom tag names have dynamic token names
-    if (token.type?.startsWith('entity.name.tag.html.ng.')) {
+    if ((_a = token.type) === null || _a === void 0 ? void 0 : _a.startsWith('entity.name.tag.html.ng.')) {
         return 'tag.name';
     }
     switch (token.type) {

package/dist/extractor/parserNgx/ngxTreeTransform.js

@@ -7,13 +7,14 @@ function transformRecursive(root) {
         case 'expr':
         case 'array':
             root.values.forEach((item, i) => {
+                var _a, _b;
                 if (item.type === 'keyInfo' && item.keyName === undefined) {
                     const nodeBefore = simplifyNode(root.values[i - 1]);
                     if (nodeBefore.type === 'dict') {
                         item.keyName = nodeBefore.value['key'];
-                        item.namespace = nodeBefore.value['ns'] ?? item.namespace;
+                        item.namespace = (_a = nodeBefore.value['ns']) !== null && _a !== void 0 ? _a : item.namespace;
                         item.defaultValue =
-                            nodeBefore.value['defaultValue'] ?? item.defaultValue;
+                            (_b = nodeBefore.value['defaultValue']) !== null && _b !== void 0 ? _b : item.defaultValue;
                     }
                     else {
                         item.keyName = nodeBefore;

package/dist/extractor/parserNgx/rules/translatePipe.js

@@ -37,7 +37,7 @@ export const translatePipe = {
             keyNode.defaultValue = args.values.shift();
             keyNode.values = args.values;
         }
-        if (options?.type === 'dict') {
+        if ((options === null || options === void 0 ? void 0 : options.type) === 'dict') {
             for (const [key, value] of Object.entries(options.value)) {
                 switch (key) {
                     case 'ns':

package/dist/extractor/parserReact/ParserReact.js

@@ -21,9 +21,7 @@ export const reactMergers = pipeMachines([
 export const ParserReact = () => {
     return Parser({
         mappers: reactMappers,
-        blocks: {
-            ...DEFAULT_BLOCKS,
-        },
+        blocks: Object.assign({}, DEFAULT_BLOCKS),
         rules: [reactCreateElement, tComponent, tFunction, useTranslate],
         merger: reactMergers,
     });

package/dist/extractor/parserSvelte/ParserSvelte.js

@@ -22,9 +22,7 @@ export const svelteMergers = pipeMachines([
 export const ParserSvelte = () => {
     return Parser({
         mappers: svelteMappers,
-        blocks: {
-            ...DEFAULT_BLOCKS,
-        },
+        blocks: Object.assign({}, DEFAULT_BLOCKS),
         rules: [tFunction, getTranslate, tComponent, scriptTag],
         treeTransform: svelteTreeTransform,
         merger: svelteMergers,

package/dist/extractor/parserVue/ParserVue.js

@@ -30,9 +30,7 @@ export const vueMergers = pipeMachines([
 export const ParserVue = () => {
     return Parser({
         mappers: vueMappers,
-        blocks: {
-            ...DEFAULT_BLOCKS,
-        },
+        blocks: Object.assign({}, DEFAULT_BLOCKS),
         rules: [
             globalTFunction,
             tFunction,

package/dist/extractor/parserVue/tokenMergers/hyphenPropsMerger.js

@@ -12,9 +12,6 @@ export const hyphenPropsMerger = {
                 break;
         }
     },
-    resultToken: (tokens) => tokens.map((t) => ({
-        ...t,
-        token: t.token.replace(/-([a-z])/g, (g) => g[1].toUpperCase()),
-    }))[0],
+    resultToken: (tokens) => tokens.map((t) => (Object.assign(Object.assign({}, t), { token: t.token.replace(/-([a-z])/g, (g) => g[1].toUpperCase()) })))[0],
     customType: 'tag.attribute.name',
 };

package/dist/extractor/parserVue/vueTreeTransform.js

@@ -1,3 +1,14 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { VUE_SCRIPT_REGULAR, VUE_SCRIPT_SETUP, VUE_COMPONENT_CONFIG, } from './contextConstants.js';
 /*
  * We get this
@@ -33,7 +44,7 @@ function bringSetupToTopLevel(context, node) {
     const setupContent = [];
     for (const item of node.values) {
         if (item.type === 'dict' && item.context === VUE_COMPONENT_CONFIG) {
-            const { setup, ...rest } = item.value;
+            const _a = item.value, { setup } = _a, rest = __rest(_a, ["setup"]);
             if (setup.type === 'expr') {
                 if (setup.values.length === 0) {
                     context.warnings.push({
@@ -42,7 +53,7 @@ function bringSetupToTopLevel(context, node) {
                     });
                 }
                 setupContent.push(...flattenOneLevel(setup.values));
-                item.value = { ...rest };
+                item.value = Object.assign({}, rest);
             }
         }
     }

package/dist/extractor/runner.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { glob } from 'tinyglobby';
 import { extname } from 'path';
 import { callWorker } from './worker.js';
@@ -6,22 +15,24 @@ export const NullNamespace = Symbol('namespace.null');
 function parseVerbose(v) {
     return Array.isArray(v) ? v : v ? [] : undefined;
 }
-export async function extractKeysFromFile(file, parserType, options, extractor) {
-    if (typeof extractor !== 'undefined') {
-        return callWorker({
-            extractor,
-            file,
-            options,
-        });
-    }
-    else if (typeof parserType !== 'undefined') {
-        return callWorker({
-            parserType,
-            file,
-            options,
-        });
-    }
-    throw new Error('Internal error: neither the parser type nor a custom extractors have been defined! Please report this.');
+export function extractKeysFromFile(file, parserType, options, extractor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof extractor !== 'undefined') {
+            return callWorker({
+                extractor,
+                file,
+                options,
+            });
+        }
+        else if (typeof parserType !== 'undefined') {
+            return callWorker({
+                parserType,
+                file,
+                options,
+            });
+        }
+        throw new Error('Internal error: neither the parser type nor a custom extractors have been defined! Please report this.');
+    });
 }
 export function findPossibleFrameworks(fileNames) {
     const possibleFrameworks = [];
@@ -59,29 +70,32 @@ function detectParserType(fileNames) {
         exitWithError(`Detected multiple possible frameworks used (${possibleFrameworks.join(', ')}), use '--parser' or 'config.parser' options`);
     }
 }
-export async function extractKeysOfFiles(opts) {
-    if (!opts.patterns?.length) {
-        exitWithError("Missing '--patterns' or 'config.patterns' option");
-    }
-    const files = await glob(opts.patterns, { onlyFiles: true });
-    if (files.length === 0) {
-        exitWithError('No files were matched for extraction');
-    }
-    let parserType = opts.parser;
-    if (!parserType && !opts.extractor) {
-        parserType = detectParserType(files);
-    }
-    const result = new Map();
-    const options = {
-        strictNamespace: Boolean(opts.strictNamespace),
-        defaultNamespace: opts.defaultNamespace,
-        verbose: parseVerbose(opts.verbose),
-    };
-    await Promise.all(files.map(async (file) => {
-        const keys = await extractKeysFromFile(file, parserType, options, opts.extractor);
-        result.set(file, keys);
-    }));
-    return result;
+export function extractKeysOfFiles(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!((_a = opts.patterns) === null || _a === void 0 ? void 0 : _a.length)) {
+            exitWithError("Missing '--patterns' or 'config.patterns' option");
+        }
+        const files = yield glob(opts.patterns, { onlyFiles: true });
+        if (files.length === 0) {
+            exitWithError('No files were matched for extraction');
+        }
+        let parserType = opts.parser;
+        if (!parserType && !opts.extractor) {
+            parserType = detectParserType(files);
+        }
+        const result = new Map();
+        const options = {
+            strictNamespace: Boolean(opts.strictNamespace),
+            defaultNamespace: opts.defaultNamespace,
+            verbose: parseVerbose(opts.verbose),
+        };
+        yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
+            const keys = yield extractKeysFromFile(file, parserType, options, opts.extractor);
+            result.set(file, keys);
+        })));
+        return result;
+    });
 }
 export function filterExtractionResult(data) {
     const result = Object.create(null);

package/dist/extractor/tokenizer.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { extname } from 'path';
 import { readFile } from 'fs/promises';
 import { createRequire } from 'module';
@@ -15,24 +24,28 @@ const GrammarFiles = {
 };
 let oniguruma;
 let registry;
-async function initializeOniguruma() {
-    const require = createRequire(import.meta.url);
-    const wasmBlobPath = require
-        .resolve('vscode-oniguruma')
-        .replace('main.js', 'onig.wasm');
-    const wasmBlob = await readFile(wasmBlobPath);
-    await Oniguruma.loadWASM(wasmBlob);
-    return {
-        createOnigScanner: (patterns) => new Oniguruma.OnigScanner(patterns),
-        createOnigString: (s) => new Oniguruma.OnigString(s),
-    };
+function initializeOniguruma() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const require = createRequire(import.meta.url);
+        const wasmBlobPath = require
+            .resolve('vscode-oniguruma')
+            .replace('main.js', 'onig.wasm');
+        const wasmBlob = yield readFile(wasmBlobPath);
+        yield Oniguruma.loadWASM(wasmBlob);
+        return {
+            createOnigScanner: (patterns) => new Oniguruma.OnigScanner(patterns),
+            createOnigString: (s) => new Oniguruma.OnigString(s),
+        };
+    });
 }
-async function loadGrammar(scope) {
-    const file = GrammarFiles[scope];
-    if (!file)
-        return null;
-    const grammar = await readFile(file, 'utf8');
-    return JSON.parse(grammar);
+function loadGrammar(scope) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = GrammarFiles[scope];
+        if (!file)
+            return null;
+        const grammar = yield readFile(file, 'utf8');
+        return JSON.parse(grammar);
+    });
 }
 function fileNameToGrammar(fileName) {
     const ext = extname(fileName);
@@ -96,22 +109,24 @@ function tokenize(code, grammar) {
     }
     return tokens;
 }
-export default async function (code, fileName) {
-    if (!oniguruma) {
-        // Lazily initialize the WebAssembly runtime
-        oniguruma = initializeOniguruma();
-        registry = new TextMate.Registry({
-            onigLib: oniguruma,
-            loadGrammar: loadGrammar,
-        });
-    }
-    const grammarName = fileNameToGrammar(fileName);
-    if (!grammarName) {
-        throw new Error(`Cannot find grammar for file type ${fileName}`);
-    }
-    const grammar = await registry.loadGrammar(grammarName);
-    if (!grammar) {
-        throw new Error(`Cannot load grammar ${grammarName}`);
-    }
-    return tokenize(code, grammar);
+export default function (code, fileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!oniguruma) {
+            // Lazily initialize the WebAssembly runtime
+            oniguruma = initializeOniguruma();
+            registry = new TextMate.Registry({
+                onigLib: oniguruma,
+                loadGrammar: loadGrammar,
+            });
+        }
+        const grammarName = fileNameToGrammar(fileName);
+        if (!grammarName) {
+            throw new Error(`Cannot find grammar for file type ${fileName}`);
+        }
+        const grammar = yield registry.loadGrammar(grammarName);
+        if (!grammar) {
+            throw new Error(`Cannot load grammar ${grammarName}`);
+        }
+        return tokenize(code, grammar);
+    });
 }

package/dist/extractor/visualizers/printTokens.js

@@ -1,7 +1,8 @@
 export const tokensList = (tokens) => {
+    var _a;
     const result = [];
     for (const t of tokens) {
-        result.push(`${JSON.stringify(t.token).padEnd(30)} ${t.type.padEnd(40)} ${t.customType ?? ''}`);
+        result.push(`${JSON.stringify(t.token).padEnd(30)} ${t.type.padEnd(40)} ${(_a = t.customType) !== null && _a !== void 0 ? _a : ''}`);
     }
     return result.join('\n');
 };

package/dist/extractor/visualizers/visualizeRules.js

@@ -28,13 +28,10 @@ export const visualizeRules = (tokens, originalString) => {
     });
     return (colorized +
         '\n\n' +
-        Object.entries({
-            ...colors,
-            ...{
-                unknown: ansi.white,
-                ignored: ansi.grey,
-            },
-        })
+        Object.entries(Object.assign(Object.assign({}, colors), {
+            unknown: ansi.white,
+            ignored: ansi.grey,
+        }))
             .map(([rule, paint]) => paint(rule))
             .join('\n'));
 };

package/dist/extractor/warnings.js

@@ -50,7 +50,7 @@ export const WarningMessages = {
 export function dumpWarnings(extractionResult) {
     let warningCount = 0;
     for (const [file, { warnings }] of extractionResult.entries()) {
-        if (warnings?.length) {
+        if (warnings === null || warnings === void 0 ? void 0 : warnings.length) {
             if (!warningCount) {
                 console.error('Warnings were emitted during extraction.');
             }
@@ -72,9 +72,10 @@ export function dumpWarnings(extractionResult) {
     return warningCount;
 }
 export function emitGitHubWarning(warning, file, line) {
+    var _a;
     if (!process.env.GITHUB_ACTIONS)
         return;
-    file = relative(process.env.GITHUB_WORKSPACE ?? process.cwd(), file);
+    file = relative((_a = process.env.GITHUB_WORKSPACE) !== null && _a !== void 0 ? _a : process.cwd(), file);
     if (warning in WarningMessages) {
         const warn = warning;
         const { name, description } = WarningMessages[warn];

package/dist/extractor/worker.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { fileURLToPath } from 'url';
 import { extname, resolve } from 'path';
 import { isMainThread, parentPort, SHARE_ENV, Worker } from 'worker_threads';
@@ -9,16 +18,18 @@ const FILE_TIME_LIMIT = 60 * 1000; // one minute
 const IS_TSX = extname(import.meta.url) === '.ts';
 // --- Worker functions
 let extractor;
-async function handleJob(args) {
-    const file = resolve(args.file);
-    const code = readFileSync(file, 'utf8');
-    if ('extractor' in args) {
-        if (!extractor) {
-            extractor = await loadModule(args.extractor).then((mdl) => mdl.default);
+function handleJob(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = resolve(args.file);
+        const code = readFileSync(file, 'utf8');
+        if ('extractor' in args) {
+            if (!extractor) {
+                extractor = yield loadModule(args.extractor).then((mdl) => mdl.default);
+            }
+            return extractor(code, file, args.options);
         }
-        return extractor(code, file, args.options);
-    }
-    return internalExtractor(code, file, args.parserType, args.options);
+        return internalExtractor(code, file, args.parserType, args.options);
+    });
 }
 function workerInit() {
     parentPort.on('message', (params) => {
@@ -73,11 +84,13 @@ function createWorker() {
     workOrDie();
     return worker;
 }
-export async function callWorker(params) {
-    const deferred = createDeferred();
-    jobQueue.push([params, deferred]);
-    if (!worker) {
-        worker = createWorker();
-    }
-    return deferred.promise;
+export function callWorker(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const deferred = createDeferred();
+        jobQueue.push([params, deferred]);
+        if (!worker) {
+            worker = createWorker();
+        }
+        return deferred.promise;
+    });
 }

package/dist/options.js

@@ -12,7 +12,7 @@ function parseUrlArgument(v) {
     try {
         return new URL(v);
     }
-    catch {
+    catch (_a) {
         throw new InvalidArgumentError('Malformed URL.');
     }
 }
@@ -44,6 +44,7 @@ export const FORMAT_OPT = new Option('--format <format>', 'Localization files fo
     'PO_PYTHON',
     'APPLE_STRINGS',
     'APPLE_XLIFF',
+    'APPLE_XCSTRINGS',
     'PROPERTIES_ICU',
     'PROPERTIES_JAVA',
     'ANDROID_XML',

package/dist/utils/apiKeyList.js

@@ -1,13 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import ansi from 'ansi-colors';
 import { loadStore } from '../config/credentials.js';
 function getProjectName(projectId, projectDetails) {
-    return projectDetails?.[projectId]?.name;
+    var _a;
+    return (_a = projectDetails === null || projectDetails === void 0 ? void 0 : projectDetails[projectId]) === null || _a === void 0 ? void 0 : _a.name;
 }
 function printToken(type, token, projectId, projectDetails) {
     let result = type === 'PAK' ? ansi.green('PAK') : ansi.blue('PAT');
     if (projectId !== undefined) {
         const projectName = getProjectName(projectId, projectDetails);
-        result += '\t ' + ansi.red(`#${projectId}` + ' ' + (projectName ?? ''));
+        result += '\t ' + ansi.red(`#${projectId}` + ' ' + (projectName !== null && projectName !== void 0 ? projectName : ''));
     }
     else {
         result += '\t ' + ansi.yellow('<all projects>');
@@ -22,25 +32,27 @@ function printToken(type, token, projectId, projectDetails) {
     }
     console.log(result);
 }
-export async function printApiKeyLists() {
-    const store = await loadStore();
-    const list = Object.entries(store);
-    if (list.length === 0) {
-        console.log(ansi.gray('No records\n'));
-    }
-    for (const [origin, server] of list) {
-        console.log(ansi.white('[') + ansi.red(origin) + ansi.white(']'));
-        if (server.user) {
-            printToken('PAT', server.user);
+export function printApiKeyLists() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const store = yield loadStore();
+        const list = Object.entries(store);
+        if (list.length === 0) {
+            console.log(ansi.gray('No records\n'));
         }
-        if (server.projects) {
-            for (const [project, token] of Object.entries(server.projects)) {
-                if (token) {
-                    printToken('PAK', token, project, server.projectDetails);
+        for (const [origin, server] of list) {
+            console.log(ansi.white('[') + ansi.red(origin) + ansi.white(']'));
+            if (server.user) {
+                printToken('PAT', server.user);
+            }
+            if (server.projects) {
+                for (const [project, token] of Object.entries(server.projects)) {
+                    if (token) {
+                        printToken('PAK', token, project, server.projectDetails);
+                    }
                 }
             }
+            console.log('\n');
         }
-        console.log('\n');
-    }
-    return;
+        return;
+    });
 }

package/dist/utils/ask.js

@@ -1,26 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import readline from 'readline'; // readline/promises is Node 17, currently supporting Node 16+
-export async function askString(question) {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(`${question} `, (a) => {
-            resolve(a);
-            rl.close();
+export function askString(question) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            rl.question(`${question} `, (a) => {
+                resolve(a);
+                rl.close();
+            });
         });
     });
 }
-export async function askBoolean(question, def = false) {
-    const yn = def === true ? '[Y/n]' : '[y/N]';
-    let res = def;
-    const str = await askString(`${question} ${yn}`);
-    const strRes = str[0]?.toLowerCase();
-    if (strRes === 'y') {
-        res = true;
-    }
-    else if (strRes === 'n') {
-        res = false;
-    }
-    return res;
+export function askBoolean(question_1) {
+    return __awaiter(this, arguments, void 0, function* (question, def = false) {
+        var _a;
+        const yn = def === true ? '[Y/n]' : '[y/N]';
+        let res = def;
+        const str = yield askString(`${question} ${yn}`);
+        const strRes = (_a = str[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (strRes === 'y') {
+            res = true;
+        }
+        else if (strRes === 'n') {
+            res = false;
+        }
+        return res;
+    });
 }