@nlabs/lex 1.49.4 → 1.50.0

package/lib/commands/init/init.js

@@ -1,93 +1,113 @@
-import { execa } from "execa";
-import { renameSync, writeFileSync } from "fs";
-import { resolve as pathResolve } from "path";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner, getPackageJson, setPackageJson } from "../../utils/app.js";
-import { getDirName } from "../../utils/file.js";
-import { log } from "../../utils/log.js";
-const init = async (appName, packageName, cmd, callback = () => ({})) => {
-  const { cliName = "Lex", install, packageManager: cmdPackageManager, quiet, typescript } = cmd;
-  const cwd = process.cwd();
-  const spinner = createSpinner(quiet);
-  log(`${cliName} is downloading the app module...`, "info", quiet);
-  spinner.start("Downloading app...");
-  const tmpPath = pathResolve(cwd, "./.lexTmp");
-  const appPath = pathResolve(cwd, `./${appName}`);
-  const dirName = getDirName();
-  const dnpPath = pathResolve(dirName, "../../../node_modules/download-npm-package/bin/cli.js");
-  await LexConfig.parseConfig(cmd);
-  const { packageManager: configPackageManager, useTypescript: configTypescript } = LexConfig.config;
-  const packageManager = cmdPackageManager || configPackageManager || "";
-  const useTypescript = typescript !== void 0 ? typescript : configTypescript || false;
-  let appModule = packageName;
-  if (!appModule) {
-    if (useTypescript) {
-      appModule = "@nlabs/arkhamjs-example-ts-react";
-    } else {
-      appModule = "@nlabs/arkhamjs-example-flow-react";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { execa } from 'execa';
+import { renameSync, writeFileSync } from 'fs';
+import { resolve as pathResolve } from 'path';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner, getPackageJson, setPackageJson } from '../../utils/app.js';
+import { getDirName } from '../../utils/file.js';
+import { log } from '../../utils/log.js';
+export const init = async (appName, packageName, cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', install, packageManager: cmdPackageManager, quiet, typescript } = cmd;
+    const cwd = process.cwd();
+    // Spinner
+    const spinner = createSpinner(quiet);
+    // Download app module into temporary directory
+    log(`${cliName} is downloading the app module...`, 'info', quiet);
+    spinner.start('Downloading app...');
+    const tmpPath = pathResolve(cwd, './.lexTmp');
+    const appPath = pathResolve(cwd, `./${appName}`);
+    const dirName = getDirName();
+    const dnpPath = pathResolve(dirName, '../../../node_modules/download-npm-package/bin/cli.js');
+    // Get custom configuration
+    await LexConfig.parseConfig(cmd);
+    const { packageManager: configPackageManager, useTypescript: configTypescript } = LexConfig.config;
+    const packageManager = cmdPackageManager || configPackageManager || '';
+    const useTypescript = typescript !== undefined ? typescript : configTypescript || false;
+    let appModule = packageName;
+    // Use base app module based on config
+    if (!appModule) {
+        if (useTypescript) {
+            appModule = '@nlabs/arkhamjs-example-ts-react';
+        } else {
+            appModule = '@nlabs/arkhamjs-example-flow-react';
+        }
     }
-  }
-  try {
-    await execa(dnpPath, [appModule, tmpPath], {});
-    spinner.succeed("Successfully downloaded app!");
-  } catch (error) {
-    console.log("error", error);
-    log(`
-${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, "error", quiet);
-    spinner.fail("Downloaded of app failed.");
-    callback(1);
-    return 1;
-  }
-  try {
-    renameSync(`${tmpPath}/${appModule}`, appPath);
-  } catch (_error) {
-    log(`
-${cliName} Error: There was an error copying ${appModule} to the current working directory.`, "error", quiet);
-    callback(1);
-    return 1;
-  }
-  const packagePath = `${appPath}/package.json`;
-  const packageJson = getPackageJson(packagePath);
-  packageJson.name = appName;
-  packageJson.description = `${cliName} created app`;
-  packageJson.version = "0.1.0";
-  delete packageJson.keywords;
-  delete packageJson.author;
-  delete packageJson.contributors;
-  delete packageJson.repository;
-  delete packageJson.homepage;
-  delete packageJson.bugs;
-  try {
-    setPackageJson(packageJson, packagePath);
-    const readmePath = `${appPath}/README.md`;
-    writeFileSync(readmePath, `# ${appName}`);
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    callback(1);
-    return 1;
-  }
-  if (install) {
-    spinner.start("Installing dependencies...");
-    process.chdir(appPath);
     try {
-      await execa(packageManager, ["install"], {
-        encoding: "utf8",
-        stdio: "inherit"
-      });
-      spinner.succeed("Successfully installed dependencies!");
+        await execa(dnpPath, [
+            appModule,
+            tmpPath
+        ], {});
+        // Stop spinner and update status
+        spinner.succeed('Successfully downloaded app!');
     } catch (error) {
-      log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed to install dependencies.");
-      callback(1);
-      return 1;
+        console.log('error', error);
+        log(`\n${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, 'error', quiet);
+        // Stop spinner and kill process
+        spinner.fail('Downloaded of app failed.');
+        // Kill process
+        callback(1);
+        return 1;
     }
-  }
-  callback(0);
-  return 0;
-};
-export {
-  init
+    // Move into configured directory
+    try {
+        renameSync(`${tmpPath}/${appModule}`, appPath);
+    } catch (_error) {
+        log(`\n${cliName} Error: There was an error copying ${appModule} to the current working directory.`, 'error', quiet);
+        callback(1);
+        return 1;
+    }
+    // Configure package.json
+    const packagePath = `${appPath}/package.json`;
+    const packageJson = getPackageJson(packagePath);
+    packageJson.name = appName;
+    packageJson.description = `${cliName} created app`;
+    packageJson.version = '0.1.0';
+    delete packageJson.keywords;
+    delete packageJson.author;
+    delete packageJson.contributors;
+    delete packageJson.repository;
+    delete packageJson.homepage;
+    delete packageJson.bugs;
+    try {
+        // Update package.json
+        setPackageJson(packageJson, packagePath);
+        // Update README
+        const readmePath = `${appPath}/README.md`;
+        writeFileSync(readmePath, `# ${appName}`);
+    } catch (error) {
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        callback(1);
+        return 1;
+    }
+    if (install) {
+        spinner.start('Installing dependencies...');
+        // Change to the app directory
+        process.chdir(appPath);
+        // Install dependencies
+        try {
+            await execa(packageManager, [
+                'install'
+            ], {
+                encoding: 'utf8',
+                stdio: 'inherit'
+            });
+            // Stop spinner
+            spinner.succeed('Successfully installed dependencies!');
+        } catch (error) {
+            // Display error message
+            log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+            // Stop spinner
+            spinner.fail('Failed to install dependencies.');
+            // Kill process
+            callback(1);
+            return 1;
+        }
+    }
+    // Kill process
+    callback(0);
+    return 0;
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/commands/init/init.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport {renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {getDirName} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport interface InitOptions {\n  readonly cliName?: string;\n  readonly install?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly typescript?: boolean;\n}\n\nexport type InitCallback = (status: number) => void;\n\nexport const init = async (\n  appName: string,\n  packageName: string,\n  cmd: InitOptions,\n  callback: InitCallback = () => ({})\n): Promise<number> => {\n  const {cliName = 'Lex', install, packageManager: cmdPackageManager, quiet, typescript} = cmd;\n  const cwd: string = process.cwd();\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Download app module into temporary directory\n  log(`${cliName} is downloading the app module...`, 'info', quiet);\n  spinner.start('Downloading app...');\n  const tmpPath: string = pathResolve(cwd, './.lexTmp');\n  const appPath: string = pathResolve(cwd, `./${appName}`);\n  const dirName = getDirName();\n  const dnpPath: string = pathResolve(dirName, '../../../node_modules/download-npm-package/bin/cli.js');\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n  const {packageManager: configPackageManager, useTypescript: configTypescript} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager || '';\n  const useTypescript: boolean = typescript !== undefined ? typescript : configTypescript || false;\n\n  let appModule: string = packageName;\n\n  // Use base app module based on config\n  if(!appModule) {\n    if(useTypescript) {\n      appModule = '@nlabs/arkhamjs-example-ts-react';\n    } else {\n      appModule = '@nlabs/arkhamjs-example-flow-react';\n    }\n  }\n\n  try {\n    await execa(dnpPath, [appModule, tmpPath], {});\n\n    // Stop spinner and update status\n    spinner.succeed('Successfully downloaded app!');\n  } catch (error) {\n    console.log('error', error);\n    log(`\\n${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, 'error', quiet);\n\n    // Stop spinner and kill process\n    spinner.fail('Downloaded of app failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n\n  // Move into configured directory\n  try {\n    renameSync(`${tmpPath}/${appModule}`, appPath);\n  } catch (_error) {\n    log(`\\n${cliName} Error: There was an error copying ${appModule} to the current working directory.`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  // Configure package.json\n  const packagePath: string = `${appPath}/package.json`;\n  const packageJson = getPackageJson(packagePath);\n  packageJson.name = appName;\n  packageJson.description = `${cliName} created app`;\n  packageJson.version = '0.1.0';\n  delete packageJson.keywords;\n  delete packageJson.author;\n  delete packageJson.contributors;\n  delete packageJson.repository;\n  delete packageJson.homepage;\n  delete packageJson.bugs;\n\n  try {\n    // Update package.json\n    setPackageJson(packageJson, packagePath);\n\n    // Update README\n    const readmePath: string = `${appPath}/README.md`;\n    writeFileSync(readmePath, `# ${appName}`);\n  } catch (error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  if(install) {\n    spinner.start('Installing dependencies...');\n\n    // Change to the app directory\n    process.chdir(appPath);\n\n    // Install dependencies\n    try {\n      await execa(packageManager, ['install'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      // Stop spinner\n      spinner.succeed('Successfully installed dependencies!');\n    } catch (error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to install dependencies.');\n\n      // Kill process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Kill process\n  callback(0);\n  return 0;\n};"],
  "mappings": "AAIA,SAAQ,aAAY;AACpB,SAAQ,YAAY,qBAAoB;AACxC,SAAQ,WAAW,mBAAkB;AAErC,SAAQ,iBAAgB;AACxB,SAAQ,eAAe,gBAAgB,sBAAqB;AAC5D,SAAQ,kBAAiB;AACzB,SAAQ,WAAU;AAYX,MAAM,OAAO,OAClB,SACA,aACA,KACA,WAAyB,OAAO,CAAC,OACb;AACpB,QAAM,EAAC,UAAU,OAAO,SAAS,gBAAgB,mBAAmB,OAAO,WAAU,IAAI;AACzF,QAAM,MAAc,QAAQ,IAAI;AAGhC,QAAM,UAAU,cAAc,KAAK;AAGnC,MAAI,GAAG,OAAO,qCAAqC,QAAQ,KAAK;AAChE,UAAQ,MAAM,oBAAoB;AAClC,QAAM,UAAkB,YAAY,KAAK,WAAW;AACpD,QAAM,UAAkB,YAAY,KAAK,KAAK,OAAO,EAAE;AACvD,QAAM,UAAU,WAAW;AAC3B,QAAM,UAAkB,YAAY,SAAS,uDAAuD;AAGpG,QAAM,UAAU,YAAY,GAAG;AAC/B,QAAM,EAAC,gBAAgB,sBAAsB,eAAe,iBAAgB,IAAI,UAAU;AAC1F,QAAM,iBAAyB,qBAAqB,wBAAwB;AAC5E,QAAM,gBAAyB,eAAe,SAAY,aAAa,oBAAoB;AAE3F,MAAI,YAAoB;AAGxB,MAAG,CAAC,WAAW;AACb,QAAG,eAAe;AAChB,kBAAY;AAAA,IACd,OAAO;AACL,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,MAAI;AACF,UAAM,MAAM,SAAS,CAAC,WAAW,OAAO,GAAG,CAAC,CAAC;AAG7C,YAAQ,QAAQ,8BAA8B;AAAA,EAChD,SAAS,OAAO;AACd,YAAQ,IAAI,SAAS,KAAK;AAC1B,QAAI;AAAA,EAAK,OAAO,0CAA0C,SAAS,qEAAqE,SAAS,KAAK;AAGtJ,YAAQ,KAAK,2BAA2B;AAGxC,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,MAAI;AACF,eAAW,GAAG,OAAO,IAAI,SAAS,IAAI,OAAO;AAAA,EAC/C,SAAS,QAAQ;AACf,QAAI;AAAA,EAAK,OAAO,sCAAsC,SAAS,sCAAsC,SAAS,KAAK;AACnH,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAGA,QAAM,cAAsB,GAAG,OAAO;AACtC,QAAM,cAAc,eAAe,WAAW;AAC9C,cAAY,OAAO;AACnB,cAAY,cAAc,GAAG,OAAO;AACpC,cAAY,UAAU;AACtB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AACnB,SAAO,YAAY;AAEnB,MAAI;AAEF,mBAAe,aAAa,WAAW;AAGvC,UAAM,aAAqB,GAAG,OAAO;AACrC,kBAAc,YAAY,KAAK,OAAO,EAAE;AAAA,EAC1C,SAAS,OAAO;AACd,QAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAC1D,aAAS,CAAC;AACV,WAAO;AAAA,EACT;AAEA,MAAG,SAAS;AACV,YAAQ,MAAM,4BAA4B;AAG1C,YAAQ,MAAM,OAAO;AAGrB,QAAI;AACF,YAAM,MAAM,gBAAgB,CAAC,SAAS,GAAG;AAAA,QACvC,UAAU;AAAA,QACV,OAAO;AAAA,MACT,CAAC;AAGD,cAAQ,QAAQ,sCAAsC;AAAA,IACxD,SAAS,OAAO;AAEd,UAAI;AAAA,EAAK,OAAO,WAAW,MAAM,OAAO,IAAI,SAAS,KAAK;AAG1D,cAAQ,KAAK,iCAAiC;AAG9C,eAAS,CAAC;AACV,aAAO;AAAA,IACT;AAAA,EACF;AAGA,WAAS,CAAC;AACV,SAAO;AACT;",
  "names": []
}

+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/init/init.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport {renameSync, writeFileSync} from 'fs';\nimport {resolve as pathResolve} from 'path';\n\nimport {LexConfig} from '../../LexConfig.js';\nimport {createSpinner, getPackageJson, setPackageJson} from '../../utils/app.js';\nimport {getDirName} from '../../utils/file.js';\nimport {log} from '../../utils/log.js';\n\nexport interface InitOptions {\n  readonly cliName?: string;\n  readonly install?: boolean;\n  readonly packageManager?: string;\n  readonly quiet?: boolean;\n  readonly typescript?: boolean;\n}\n\nexport type InitCallback = (status: number) => void;\n\nexport const init = async (\n  appName: string,\n  packageName: string,\n  cmd: InitOptions,\n  callback: InitCallback = () => ({})\n): Promise<number> => {\n  const {cliName = 'Lex', install, packageManager: cmdPackageManager, quiet, typescript} = cmd;\n  const cwd: string = process.cwd();\n\n  // Spinner\n  const spinner = createSpinner(quiet);\n\n  // Download app module into temporary directory\n  log(`${cliName} is downloading the app module...`, 'info', quiet);\n  spinner.start('Downloading app...');\n  const tmpPath: string = pathResolve(cwd, './.lexTmp');\n  const appPath: string = pathResolve(cwd, `./${appName}`);\n  const dirName = getDirName();\n  const dnpPath: string = pathResolve(dirName, '../../../node_modules/download-npm-package/bin/cli.js');\n\n  // Get custom configuration\n  await LexConfig.parseConfig(cmd);\n  const {packageManager: configPackageManager, useTypescript: configTypescript} = LexConfig.config;\n  const packageManager: string = cmdPackageManager || configPackageManager || '';\n  const useTypescript: boolean = typescript !== undefined ? typescript : configTypescript || false;\n\n  let appModule: string = packageName;\n\n  // Use base app module based on config\n  if(!appModule) {\n    if(useTypescript) {\n      appModule = '@nlabs/arkhamjs-example-ts-react';\n    } else {\n      appModule = '@nlabs/arkhamjs-example-flow-react';\n    }\n  }\n\n  try {\n    await execa(dnpPath, [appModule, tmpPath], {});\n\n    // Stop spinner and update status\n    spinner.succeed('Successfully downloaded app!');\n  } catch(error) {\n    console.log('error', error);\n    log(`\\n${cliName} Error: There was an error downloading ${appModule}. Make sure the package exists and there is a network connection.`, 'error', quiet);\n\n    // Stop spinner and kill process\n    spinner.fail('Downloaded of app failed.');\n\n    // Kill process\n    callback(1);\n    return 1;\n  }\n\n  // Move into configured directory\n  try {\n    renameSync(`${tmpPath}/${appModule}`, appPath);\n  } catch(_error) {\n    log(`\\n${cliName} Error: There was an error copying ${appModule} to the current working directory.`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  // Configure package.json\n  const packagePath: string = `${appPath}/package.json`;\n  const packageJson = getPackageJson(packagePath);\n  packageJson.name = appName;\n  packageJson.description = `${cliName} created app`;\n  packageJson.version = '0.1.0';\n  delete packageJson.keywords;\n  delete packageJson.author;\n  delete packageJson.contributors;\n  delete packageJson.repository;\n  delete packageJson.homepage;\n  delete packageJson.bugs;\n\n  try {\n    // Update package.json\n    setPackageJson(packageJson, packagePath);\n\n    // Update README\n    const readmePath: string = `${appPath}/README.md`;\n    writeFileSync(readmePath, `# ${appName}`);\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  if(install) {\n    spinner.start('Installing dependencies...');\n\n    // Change to the app directory\n    process.chdir(appPath);\n\n    // Install dependencies\n    try {\n      await execa(packageManager, ['install'], {\n        encoding: 'utf8',\n        stdio: 'inherit'\n      });\n\n      // Stop spinner\n      spinner.succeed('Successfully installed dependencies!');\n    } catch(error) {\n      // Display error message\n      log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n\n      // Stop spinner\n      spinner.fail('Failed to install dependencies.');\n\n      // Kill process\n      callback(1);\n      return 1;\n    }\n  }\n\n  // Kill process\n  callback(0);\n  return 0;\n};"],"names":["execa","renameSync","writeFileSync","resolve","pathResolve","LexConfig","createSpinner","getPackageJson","setPackageJson","getDirName","log","init","appName","packageName","cmd","callback","cliName","install","packageManager","cmdPackageManager","quiet","typescript","cwd","process","spinner","start","tmpPath","appPath","dirName","dnpPath","parseConfig","configPackageManager","useTypescript","configTypescript","config","undefined","appModule","succeed","error","console","fail","_error","packagePath","packageJson","name","description","version","keywords","author","contributors","repository","homepage","bugs","readmePath","message","chdir","encoding","stdio"],"mappings":"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"}

package/lib/commands/link/link.js

@@ -1,15 +1,19 @@
-import { LexConfig } from "../../LexConfig.js";
-import { checkLinkedModules } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const linked = async (cmd, callback = () => ({})) => {
-  const { cliName = "Lex", quiet } = cmd;
-  log(`${cliName} checking for linked modules...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  checkLinkedModules();
-  callback(0);
-  return Promise.resolve(0);
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { LexConfig } from '../../LexConfig.js';
+import { checkLinkedModules } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+export const linked = async (cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', quiet } = cmd;
+    // Display status
+    log(`${cliName} checking for linked modules...`, 'info', quiet);
+    // Get custom configuration
+    await LexConfig.parseConfig(cmd);
+    // Check for linked modules
+    checkLinkedModules();
+    callback(0);
+    return Promise.resolve(0);
 };
-export {
-  linked
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1hbmRzL2xpbmsvbGluay50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7TGV4Q29uZmlnfSBmcm9tICcuLi8uLi9MZXhDb25maWcuanMnO1xuaW1wb3J0IHtjaGVja0xpbmtlZE1vZHVsZXN9IGZyb20gJy4uLy4uL3V0aWxzL2FwcC5qcyc7XG5pbXBvcnQge2xvZ30gZnJvbSAnLi4vLi4vdXRpbHMvbG9nLmpzJztcblxuZXhwb3J0IGludGVyZmFjZSBMaW5rT3B0aW9ucyB7XG4gIHJlYWRvbmx5IGNsaU5hbWU/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IHF1aWV0PzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IHR5cGUgTGlua0NhbGxiYWNrID0gKHN0YXR1czogbnVtYmVyKSA9PiB2b2lkO1xuXG5leHBvcnQgY29uc3QgbGlua2VkID0gYXN5bmMgKGNtZDogTGlua09wdGlvbnMsIGNhbGxiYWNrOiBMaW5rQ2FsbGJhY2sgPSAoKSA9PiAoe30pKTogUHJvbWlzZTxudW1iZXI+ID0+IHtcbiAgY29uc3Qge2NsaU5hbWUgPSAnTGV4JywgcXVpZXR9ID0gY21kO1xuXG4gIC8vIERpc3BsYXkgc3RhdHVzXG4gIGxvZyhgJHtjbGlOYW1lfSBjaGVja2luZyBmb3IgbGlua2VkIG1vZHVsZXMuLi5gLCAnaW5mbycsIHF1aWV0KTtcblxuICAvLyBHZXQgY3VzdG9tIGNvbmZpZ3VyYXRpb25cbiAgYXdhaXQgTGV4Q29uZmlnLnBhcnNlQ29uZmlnKGNtZCk7XG5cbiAgLy8gQ2hlY2sgZm9yIGxpbmtlZCBtb2R1bGVzXG4gIGNoZWNrTGlua2VkTW9kdWxlcygpO1xuICBjYWxsYmFjaygwKTtcbiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgwKTtcbn07Il0sCiAgIm1hcHBpbmdzIjogIkFBSUEsU0FBUSxpQkFBZ0I7QUFDeEIsU0FBUSwwQkFBeUI7QUFDakMsU0FBUSxXQUFVO0FBU1gsTUFBTSxTQUFTLE9BQU8sS0FBa0IsV0FBeUIsT0FBTyxDQUFDLE9BQXdCO0FBQ3RHLFFBQU0sRUFBQyxVQUFVLE9BQU8sTUFBSyxJQUFJO0FBR2pDLE1BQUksR0FBRyxPQUFPLG1DQUFtQyxRQUFRLEtBQUs7QUFHOUQsUUFBTSxVQUFVLFlBQVksR0FBRztBQUcvQixxQkFBbUI7QUFDbkIsV0FBUyxDQUFDO0FBQ1YsU0FBTyxRQUFRLFFBQVEsQ0FBQztBQUMxQjsiLAogICJuYW1lcyI6IFtdCn0K
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9saW5rL2xpbmsudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7TGV4Q29uZmlnfSBmcm9tICcuLi8uLi9MZXhDb25maWcuanMnO1xuaW1wb3J0IHtjaGVja0xpbmtlZE1vZHVsZXN9IGZyb20gJy4uLy4uL3V0aWxzL2FwcC5qcyc7XG5pbXBvcnQge2xvZ30gZnJvbSAnLi4vLi4vdXRpbHMvbG9nLmpzJztcblxuZXhwb3J0IGludGVyZmFjZSBMaW5rT3B0aW9ucyB7XG4gIHJlYWRvbmx5IGNsaU5hbWU/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IHF1aWV0PzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IHR5cGUgTGlua0NhbGxiYWNrID0gKHN0YXR1czogbnVtYmVyKSA9PiB2b2lkO1xuXG5leHBvcnQgY29uc3QgbGlua2VkID0gYXN5bmMgKGNtZDogTGlua09wdGlvbnMsIGNhbGxiYWNrOiBMaW5rQ2FsbGJhY2sgPSAoKSA9PiAoe30pKTogUHJvbWlzZTxudW1iZXI+ID0+IHtcbiAgY29uc3Qge2NsaU5hbWUgPSAnTGV4JywgcXVpZXR9ID0gY21kO1xuXG4gIC8vIERpc3BsYXkgc3RhdHVzXG4gIGxvZyhgJHtjbGlOYW1lfSBjaGVja2luZyBmb3IgbGlua2VkIG1vZHVsZXMuLi5gLCAnaW5mbycsIHF1aWV0KTtcblxuICAvLyBHZXQgY3VzdG9tIGNvbmZpZ3VyYXRpb25cbiAgYXdhaXQgTGV4Q29uZmlnLnBhcnNlQ29uZmlnKGNtZCk7XG5cbiAgLy8gQ2hlY2sgZm9yIGxpbmtlZCBtb2R1bGVzXG4gIGNoZWNrTGlua2VkTW9kdWxlcygpO1xuICBjYWxsYmFjaygwKTtcbiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgwKTtcbn07Il0sIm5hbWVzIjpbIkxleENvbmZpZyIsImNoZWNrTGlua2VkTW9kdWxlcyIsImxvZyIsImxpbmtlZCIsImNtZCIsImNhbGxiYWNrIiwiY2xpTmFtZSIsInF1aWV0IiwicGFyc2VDb25maWciLCJQcm9taXNlIiwicmVzb2x2ZSJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBQ0QsU0FBUUEsU0FBUyxRQUFPLHFCQUFxQjtBQUM3QyxTQUFRQyxrQkFBa0IsUUFBTyxxQkFBcUI7QUFDdEQsU0FBUUMsR0FBRyxRQUFPLHFCQUFxQjtBQVN2QyxPQUFPLE1BQU1DLFNBQVMsT0FBT0MsS0FBa0JDLFdBQXlCLElBQU8sQ0FBQSxDQUFDLENBQUEsQ0FBRTtJQUNoRixNQUFNLEVBQUNDLFVBQVUsS0FBSyxFQUFFQyxLQUFLLEVBQUMsR0FBR0g7SUFFakMsaUJBQWlCO0lBQ2pCRixJQUFJLEdBQUdJLFFBQVEsK0JBQStCLENBQUMsRUFBRSxRQUFRQztJQUV6RCwyQkFBMkI7SUFDM0IsTUFBTVAsVUFBVVEsV0FBVyxDQUFDSjtJQUU1QiwyQkFBMkI7SUFDM0JIO0lBQ0FJLFNBQVM7SUFDVCxPQUFPSSxRQUFRQyxPQUFPLENBQUM7QUFDekIsRUFBRSJ9