Initial commit

node_modules/office-addin-lint/.vscode/launch.json

@@ -0,0 +1,52 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+          "name": "Command Line: check",
+          "type": "node",
+          "request": "launch",
+          "program": "${workspaceFolder}/lib/cli.js",
+          "args": ["check"]
+        },
+        {
+            "name": "Command Line: prettier",
+            "type": "node",
+            "request": "launch",
+            "program": "${workspaceFolder}/lib/cli.js",
+            "args": ["prettier"]
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}\\lib\\main.js",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        }, 
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Debug Tests",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "args": [
+                "-u",
+                "tdd",
+                "--timeout",
+                "999999",
+                "--colors",
+                "${workspaceFolder}/test",
+                "-r",
+                "ts-node/register",
+                "${workspaceFolder}/test/**/*.ts"
+            ],
+            "internalConsoleOptions": "openOnSessionStart"
+        }
+    ]
+}

node_modules/office-addin-lint/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

node_modules/office-addin-lint/README.md

@@ -0,0 +1,79 @@
+# Office-Addin-Lint
+
+Ensure code quality with lint rules and consistent code formatting.
+
+## Command-Line Interface
+* [check](#check)
+* [fix](#fix)
+* [prettier](#prettier)
+
+#
+
+### check 
+Check the source code for problems.
+
+Syntax:
+
+`office-addin-lint check [options]`
+
+Options:
+
+`--files <files>`
+
+Specify the files to check. Default: `src/**/*.{ts,tsx,js,jsx}`
+ 
+#
+
+### fix 
+Apply fixes for problems found in the source code.
+
+Syntax:
+
+`office-addin-lint fix [options]`
+
+Options:
+
+`--files <files>`
+
+Specify the files to fix. Default: `src/**/*.{ts,tsx,js,jsx}`
+ 
+#
+
+### prettier 
+Make the source code prettier.
+
+Syntax:
+
+`office-addin-lint prettier [options]`
+
+Options:
+
+`--files <files>`
+
+Specify the files to fix. Default: `src/**/*.{ts,tsx,js,jsx}`
+ 
+#
+
+## Package installation
+Steps to follow when installing the package and configuring for use.
+
+Install the following packages:
+
+`npm install -D office-addin-lint`
+
+`npm install -D office-addin-prettier-config`
+
+#
+
+Add the following to package.json:
+
+    Under scripts add the following to enable the 3 actions:
+
+        "lint": "office-addin-lint check",
+        "lint:fix": "office-addin-lint fix",
+        "prettier": "office-addin-lint prettier"`
+
+    At top level add the following to enable the prettier config:
+
+        "prettier": "office-addin-prettier-config"
+#

node_modules/office-addin-lint/config/eslint.config.mjs

@@ -0,0 +1,14 @@
+import officeAddins from "eslint-plugin-office-addins";
+import tsParser from "@typescript-eslint/parser";
+
+export default [
+  ...officeAddins.configs.recommended,
+  {
+    plugins: {
+      "office-addins": officeAddins,
+    },
+    languageOptions: {
+      parser: tsParser,
+    },
+  },
+];

node_modules/office-addin-lint/config/eslint.config.test.mjs

@@ -0,0 +1,14 @@
+import officeAddins from "eslint-plugin-office-addins";
+import tsParser from "@typescript-eslint/parser";
+
+export default [
+  ...officeAddins.configs.test,
+  {
+    plugins: {
+      "office-addins": officeAddins,
+    },
+    languageOptions: {
+      parser: tsParser,
+    },
+  },
+];

node_modules/office-addin-lint/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

node_modules/office-addin-lint/lib/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+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);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const office_addin_usage_data_1 = require("office-addin-usage-data");
+const commands = __importStar(require("./commands"));
+const defaults = __importStar(require("./defaults"));
+/* global process */
+const commander = new commander_1.Command();
+commander.name("office-addin-lint");
+commander.version(process.env.npm_package_version || "(version not available)");
+commander
+    .command("check")
+    .option("--files <files>", `Specifies the source files to check. Default: ${defaults.lintFiles}`)
+    .option("--test", "Use the test lint configuration")
+    .description(`Check source files against lint rules.`)
+    .action(commands.lint);
+commander
+    .command("fix")
+    .option("--files <files>", `Specifies the source files to fix. Default: ${defaults.lintFiles}`)
+    .option("--test", "Use the test lint configuration")
+    .description(`Apply fixes to source based on lint rules.`)
+    .action(commands.lintFix);
+commander
+    .command("prettier")
+    .option("--files <files>", `Specifies which files to use. Default: ${defaults.lintFiles}`)
+    .description(`Make the source prettier.`)
+    .action(commands.prettier);
+// if the command is not known, display an error
+commander.on("command:*", function () {
+    (0, office_addin_usage_data_1.logErrorMessage)(`The command syntax is not valid.\n`);
+    process.exitCode = 1;
+    commander.help();
+});
+if (process.argv.length > 2) {
+    commander.parse(process.argv);
+}
+else {
+    commander.help();
+}
+//# sourceMappingURL=cli.js.map

node_modules/office-addin-lint/lib/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";;AAEA,4DAA4D;AAC5D,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElC,yCAAoC;AACpC,qEAA0D;AAC1D,qDAAuC;AACvC,qDAAuC;AAEvC,oBAAoB;AAEpB,MAAM,SAAS,GAAG,IAAI,mBAAO,EAAE,CAAC;AAEhC,SAAS,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;AACpC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,yBAAyB,CAAC,CAAC;AAEhF,SAAS;KACN,OAAO,CAAC,OAAO,CAAC;KAChB,MAAM,CAAC,iBAAiB,EAAE,iDAAiD,QAAQ,CAAC,SAAS,EAAE,CAAC;KAChG,MAAM,CAAC,QAAQ,EAAE,iCAAiC,CAAC;KACnD,WAAW,CAAC,wCAAwC,CAAC;KACrD,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAEzB,SAAS;KACN,OAAO,CAAC,KAAK,CAAC;KACd,MAAM,CAAC,iBAAiB,EAAE,+CAA+C,QAAQ,CAAC,SAAS,EAAE,CAAC;KAC9F,MAAM,CAAC,QAAQ,EAAE,iCAAiC,CAAC;KACnD,WAAW,CAAC,4CAA4C,CAAC;KACzD,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;AAE5B,SAAS;KACN,OAAO,CAAC,UAAU,CAAC;KACnB,MAAM,CAAC,iBAAiB,EAAE,0CAA0C,QAAQ,CAAC,SAAS,EAAE,CAAC;KACzF,WAAW,CAAC,2BAA2B,CAAC;KACxC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAE7B,gDAAgD;AAChD,SAAS,CAAC,EAAE,CAAC,WAAW,EAAE;IACxB,IAAA,yCAAe,EAAC,oCAAoC,CAAC,CAAC;IACtD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACrB,SAAS,CAAC,IAAI,EAAE,CAAC;AACnB,CAAC,CAAC,CAAC;AAEH,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;IAC5B,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;KAAM,CAAC;IACN,SAAS,CAAC,IAAI,EAAE,CAAC;AACnB,CAAC"}

node_modules/office-addin-lint/lib/commands.d.ts

@@ -0,0 +1,4 @@
+import { OptionValues } from "commander";
+export declare function lint(options: OptionValues): Promise<void>;
+export declare function lintFix(options: OptionValues): Promise<void>;
+export declare function prettier(options: OptionValues): Promise<void>;

node_modules/office-addin-lint/lib/commands.js

@@ -0,0 +1,127 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+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);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lint = lint;
+exports.lintFix = lintFix;
+exports.prettier = prettier;
+const office_addin_usage_data_1 = require("office-addin-usage-data");
+const defaults = __importStar(require("./defaults"));
+const lint_1 = require("./lint");
+const defaults_1 = require("./defaults");
+/* global process */
+/**
+ * Determines path to files to run lint against. Priority order follows:
+ * 1 --files option passed through cli
+ * 2 lint_files config property in package.json
+ * 3 default location
+ * @param command command options which can contain files
+ */
+function getPathToFiles(options) {
+    const pathToFiles = options.files
+        ? options.files
+        : process.env.npm_package_config_lint_files;
+    return pathToFiles ? pathToFiles : defaults.lintFiles;
+}
+function lint(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pathToFiles = getPathToFiles(options);
+            const useTestConfig = options.test;
+            yield (0, lint_1.performLintCheck)(pathToFiles, useTestConfig);
+            defaults_1.usageDataObject.reportSuccess("lint");
+        }
+        catch (err) {
+            if (typeof err.status == "number") {
+                process.exitCode = err.status;
+            }
+            else {
+                process.exitCode = defaults.ESLintExitCode.CommandFailed;
+                defaults_1.usageDataObject.reportException("lint", err);
+                (0, office_addin_usage_data_1.logErrorMessage)(err);
+            }
+        }
+    });
+}
+function lintFix(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pathToFiles = getPathToFiles(options);
+            const useTestConfig = options.test;
+            yield (0, lint_1.performLintFix)(pathToFiles, useTestConfig);
+            defaults_1.usageDataObject.reportSuccess("lintFix");
+        }
+        catch (err) {
+            if (typeof err.status == "number") {
+                process.exitCode = err.status;
+            }
+            else {
+                process.exitCode = defaults.ESLintExitCode.CommandFailed;
+                defaults_1.usageDataObject.reportException("lintFix", err);
+                (0, office_addin_usage_data_1.logErrorMessage)(err);
+            }
+        }
+    });
+}
+function prettier(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pathToFiles = getPathToFiles(options);
+            yield (0, lint_1.makeFilesPrettier)(pathToFiles);
+            defaults_1.usageDataObject.reportSuccess("prettier");
+        }
+        catch (err) {
+            if (typeof err.status == "number") {
+                process.exitCode = err.status;
+            }
+            else {
+                process.exitCode = defaults.PrettierExitCode.CommandFailed;
+                defaults_1.usageDataObject.reportException("prettier", err);
+                (0, office_addin_usage_data_1.logErrorMessage)(err);
+            }
+        }
+    });
+}
+//# sourceMappingURL=commands.js.map

node_modules/office-addin-lint/lib/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"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"}

node_modules/office-addin-lint/lib/defaults.d.ts

@@ -0,0 +1,13 @@
+import { OfficeAddinUsageData } from "office-addin-usage-data";
+export declare const lintFiles = "src/**/*.{ts,tsx,js,jsx}";
+export declare enum ESLintExitCode {
+    NoLintErrors = 0,
+    HasLintError = 1,
+    CommandFailed = 2
+}
+export declare enum PrettierExitCode {
+    NoFormattingProblems = 0,
+    HasFormattingProblem = 1,
+    CommandFailed = 2
+}
+export declare const usageDataObject: OfficeAddinUsageData;

node_modules/office-addin-lint/lib/defaults.js

@@ -0,0 +1,26 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usageDataObject = exports.PrettierExitCode = exports.ESLintExitCode = exports.lintFiles = void 0;
+const office_addin_usage_data_1 = require("office-addin-usage-data");
+exports.lintFiles = "src/**/*.{ts,tsx,js,jsx}";
+var ESLintExitCode;
+(function (ESLintExitCode) {
+    ESLintExitCode[ESLintExitCode["NoLintErrors"] = 0] = "NoLintErrors";
+    ESLintExitCode[ESLintExitCode["HasLintError"] = 1] = "HasLintError";
+    ESLintExitCode[ESLintExitCode["CommandFailed"] = 2] = "CommandFailed";
+})(ESLintExitCode || (exports.ESLintExitCode = ESLintExitCode = {}));
+var PrettierExitCode;
+(function (PrettierExitCode) {
+    PrettierExitCode[PrettierExitCode["NoFormattingProblems"] = 0] = "NoFormattingProblems";
+    PrettierExitCode[PrettierExitCode["HasFormattingProblem"] = 1] = "HasFormattingProblem";
+    PrettierExitCode[PrettierExitCode["CommandFailed"] = 2] = "CommandFailed";
+})(PrettierExitCode || (exports.PrettierExitCode = PrettierExitCode = {}));
+// Usage data defaults
+exports.usageDataObject = new office_addin_usage_data_1.OfficeAddinUsageData({
+    projectName: "office-addin-lint",
+    instrumentationKey: office_addin_usage_data_1.instrumentationKeyForOfficeAddinCLITools,
+    raisePrompt: false,
+});
+//# sourceMappingURL=defaults.js.map

node_modules/office-addin-lint/lib/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":";AAAA,4DAA4D;AAC5D,kCAAkC;;;AAElC,qEAGiC;AAEpB,QAAA,SAAS,GAAG,0BAA0B,CAAC;AAEpD,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,mEAAgB,CAAA;IAChB,mEAAgB,CAAA;IAChB,qEAAiB,CAAA;AACnB,CAAC,EAJW,cAAc,8BAAd,cAAc,QAIzB;AAED,IAAY,gBAIX;AAJD,WAAY,gBAAgB;IAC1B,uFAAwB,CAAA;IACxB,uFAAwB,CAAA;IACxB,yEAAiB,CAAA;AACnB,CAAC,EAJW,gBAAgB,gCAAhB,gBAAgB,QAI3B;AAED,sBAAsB;AACT,QAAA,eAAe,GAAyB,IAAI,8CAAoB,CAAC;IAC5E,WAAW,EAAE,mBAAmB;IAChC,kBAAkB,EAAE,kEAAwC;IAC5D,WAAW,EAAE,KAAK;CACnB,CAAC,CAAC"}

node_modules/office-addin-lint/lib/lint.d.ts

@@ -0,0 +1,6 @@
+export declare function getLintCheckCommand(files: string, useTestConfig?: boolean): string;
+export declare function performLintCheck(files: string, useTestConfig?: boolean): void;
+export declare function getLintFixCommand(files: string, useTestConfig?: boolean): string;
+export declare function performLintFix(files: string, useTestConfig?: boolean): void;
+export declare function getPrettierCommand(files: string): string;
+export declare function makeFilesPrettier(files: string): void;

node_modules/office-addin-lint/lib/lint.js

@@ -0,0 +1,107 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLintCheckCommand = getLintCheckCommand;
+exports.performLintCheck = performLintCheck;
+exports.getLintFixCommand = getLintFixCommand;
+exports.performLintFix = performLintFix;
+exports.getPrettierCommand = getPrettierCommand;
+exports.makeFilesPrettier = makeFilesPrettier;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const defaults_1 = require("./defaults");
+/* global process require __dirname */
+const eslintPath = require.resolve("eslint");
+const prettierPath = require.resolve("prettier");
+const eslintDir = path_1.default.parse(eslintPath).dir;
+const eslintFilePath = path_1.default.resolve(eslintDir, "../bin/eslint.js");
+const prettierFilePath = path_1.default.resolve(prettierPath, "../bin/prettier.cjs");
+const eslintConfigPath = path_1.default.resolve(__dirname, "../config/eslint.config.mjs");
+const eslintTestConfigPath = path_1.default.resolve(__dirname, "../config/eslint.config.test.mjs");
+function execCommand(command) {
+    const execSync = require("child_process").execSync;
+    execSync(command, { stdio: "inherit" });
+}
+function normalizeFilePath(filePath) {
+    return filePath.replace(/ /g, "\\ "); // Converting space to '\\'
+}
+function getEsLintBaseCommand(useTestConfig = false) {
+    const projLintConfig = path_1.default.resolve(process.cwd(), "eslint.config.mjs");
+    const prodConfig = fs_1.default.existsSync(projLintConfig) ? projLintConfig : eslintConfigPath;
+    const configFilePath = useTestConfig ? eslintTestConfigPath : prodConfig;
+    const eslintBaseCommand = `node "${eslintFilePath}" -c "${configFilePath}"`;
+    return eslintBaseCommand;
+}
+function getLintCheckCommand(files, useTestConfig = false) {
+    const eslintCommand = `${getEsLintBaseCommand(useTestConfig)} "${normalizeFilePath(files)}"`;
+    return eslintCommand;
+}
+function performLintCheck(files, useTestConfig = false) {
+    try {
+        const command = getLintCheckCommand(files, useTestConfig);
+        execCommand(command);
+        defaults_1.usageDataObject.reportSuccess("performLintCheck()", { exitCode: defaults_1.ESLintExitCode.NoLintErrors });
+    }
+    catch (err) {
+        if (err.status && err.status == defaults_1.ESLintExitCode.HasLintError) {
+            defaults_1.usageDataObject.reportExpectedException("performLintCheck()", err, {
+                exitCode: defaults_1.ESLintExitCode.HasLintError,
+            });
+        }
+        else {
+            defaults_1.usageDataObject.reportException("performLintCheck()", err);
+        }
+        throw err;
+    }
+}
+function getLintFixCommand(files, useTestConfig = false) {
+    const eslintCommand = `${getEsLintBaseCommand(useTestConfig)} --fix ${normalizeFilePath(files)}`;
+    return eslintCommand;
+}
+function performLintFix(files, useTestConfig = false) {
+    try {
+        const command = getLintFixCommand(files, useTestConfig);
+        execCommand(command);
+        defaults_1.usageDataObject.reportSuccess("performLintFix()", { exitCode: defaults_1.ESLintExitCode.NoLintErrors });
+    }
+    catch (err) {
+        if (err.status && err.status == defaults_1.ESLintExitCode.HasLintError) {
+            defaults_1.usageDataObject.reportExpectedException("performLintFix()", err, {
+                exitCode: defaults_1.ESLintExitCode.HasLintError,
+            });
+        }
+        else {
+            defaults_1.usageDataObject.reportException("performLintFix()", err);
+        }
+        throw err;
+    }
+}
+function getPrettierCommand(files) {
+    const prettierFixCommand = `node ${prettierFilePath} --parser typescript --write ${normalizeFilePath(files)}`;
+    return prettierFixCommand;
+}
+function makeFilesPrettier(files) {
+    try {
+        const command = getPrettierCommand(files);
+        execCommand(command);
+        defaults_1.usageDataObject.reportSuccess("makeFilesPrettier()", {
+            exitCode: defaults_1.PrettierExitCode.NoFormattingProblems,
+        });
+    }
+    catch (err) {
+        if (err.status && err.status == defaults_1.PrettierExitCode.HasFormattingProblem) {
+            defaults_1.usageDataObject.reportExpectedException("makeFilesPrettier()", err, {
+                exitCode: defaults_1.PrettierExitCode.HasFormattingProblem,
+            });
+        }
+        else {
+            defaults_1.usageDataObject.reportException("makeFilesPrettier()", err);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=lint.js.map

node_modules/office-addin-lint/lib/lint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.js","sourceRoot":"","sources":["../src/lint.ts"],"names":[],"mappings":";AAAA,4DAA4D;AAC5D,kCAAkC;;;;;AAiClC,kDAGC;AAED,4CAeC;AAED,8CAGC;AAED,wCAeC;AAED,gDAGC;AAED,8CAiBC;AAjGD,4CAAoB;AACpB,gDAAwB;AACxB,yCAA+E;AAE/E,sCAAsC;AAEtC,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAC7C,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AACjD,MAAM,SAAS,GAAG,cAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC;AAC7C,MAAM,cAAc,GAAG,cAAI,CAAC,OAAO,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;AACnE,MAAM,gBAAgB,GAAG,cAAI,CAAC,OAAO,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAAC;AAC3E,MAAM,gBAAgB,GAAG,cAAI,CAAC,OAAO,CAAC,SAAS,EAAE,6BAA6B,CAAC,CAAC;AAChF,MAAM,oBAAoB,GAAG,cAAI,CAAC,OAAO,CAAC,SAAS,EAAE,kCAAkC,CAAC,CAAC;AAEzF,SAAS,WAAW,CAAC,OAAe;IAClC,MAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;AAC1C,CAAC;AAED,SAAS,iBAAiB,CAAC,QAAgB;IACzC,OAAO,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,2BAA2B;AACnE,CAAC;AAED,SAAS,oBAAoB,CAAC,gBAAyB,KAAK;IAC1D,MAAM,cAAc,GAAG,cAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,mBAAmB,CAAC,CAAC;IACxE,MAAM,UAAU,GAAG,YAAE,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,CAAC;IACrF,MAAM,cAAc,GAAG,aAAa,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,UAAU,CAAC;IACzE,MAAM,iBAAiB,GAAW,SAAS,cAAc,SAAS,cAAc,GAAG,CAAC;IACpF,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED,SAAgB,mBAAmB,CAAC,KAAa,EAAE,gBAAyB,KAAK;IAC/E,MAAM,aAAa,GAAW,GAAG,oBAAoB,CAAC,aAAa,CAAC,KAAK,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC;IACrG,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,SAAgB,gBAAgB,CAAC,KAAa,EAAE,gBAAyB,KAAK;IAC5E,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QAC1D,WAAW,CAAC,OAAO,CAAC,CAAC;QACrB,0BAAe,CAAC,aAAa,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,yBAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IACjG,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,yBAAc,CAAC,YAAY,EAAE,CAAC;YAC5D,0BAAe,CAAC,uBAAuB,CAAC,oBAAoB,EAAE,GAAG,EAAE;gBACjE,QAAQ,EAAE,yBAAc,CAAC,YAAY;aACtC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,0BAAe,CAAC,eAAe,CAAC,oBAAoB,EAAE,GAAG,CAAC,CAAC;QAC7D,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAED,SAAgB,iBAAiB,CAAC,KAAa,EAAE,gBAAyB,KAAK;IAC7E,MAAM,aAAa,GAAW,GAAG,oBAAoB,CAAC,aAAa,CAAC,UAAU,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;IACzG,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,SAAgB,cAAc,CAAC,KAAa,EAAE,gBAAyB,KAAK;IAC1E,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,iBAAiB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QACxD,WAAW,CAAC,OAAO,CAAC,CAAC;QACrB,0BAAe,CAAC,aAAa,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,yBAAc,CAAC,YAAY,EAAE,CAAC,CAAC;IAC/F,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,yBAAc,CAAC,YAAY,EAAE,CAAC;YAC5D,0BAAe,CAAC,uBAAuB,CAAC,kBAAkB,EAAE,GAAG,EAAE;gBAC/D,QAAQ,EAAE,yBAAc,CAAC,YAAY;aACtC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,0BAAe,CAAC,eAAe,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC;AAED,SAAgB,kBAAkB,CAAC,KAAa;IAC9C,MAAM,kBAAkB,GAAW,QAAQ,gBAAgB,gCAAgC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;IACtH,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED,SAAgB,iBAAiB,CAAC,KAAa;IAC7C,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC1C,WAAW,CAAC,OAAO,CAAC,CAAC;QACrB,0BAAe,CAAC,aAAa,CAAC,qBAAqB,EAAE;YACnD,QAAQ,EAAE,2BAAgB,CAAC,oBAAoB;SAChD,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,2BAAgB,CAAC,oBAAoB,EAAE,CAAC;YACtE,0BAAe,CAAC,uBAAuB,CAAC,qBAAqB,EAAE,GAAG,EAAE;gBAClE,QAAQ,EAAE,2BAAgB,CAAC,oBAAoB;aAChD,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,0BAAe,CAAC,eAAe,CAAC,qBAAqB,EAAE,GAAG,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}

node_modules/office-addin-lint/lib/main.d.ts

@@ -0,0 +1,2 @@
+export * from "./defaults";
+export * from "./lint";

node_modules/office-addin-lint/lib/main.js

@@ -0,0 +1,21 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+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);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./defaults"), exports);
+__exportStar(require("./lint"), exports);
+//# sourceMappingURL=main.js.map

node_modules/office-addin-lint/lib/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":";AAAA,4DAA4D;AAC5D,kCAAkC;;;;;;;;;;;;;;;;AAElC,6CAA2B;AAC3B,yCAAuB"}

node_modules/office-addin-lint/node_modules/commander/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/office-addin-lint/node_modules/commander/esm.mjs

@@ -0,0 +1,16 @@
+import commander from './index.js';
+
+// wrapper to provide named exports for ESM.
+export const {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError, // deprecated old name
+  Command,
+  Argument,
+  Option,
+  Help,
+} = commander;

node_modules/office-addin-lint/node_modules/commander/index.js

@@ -0,0 +1,24 @@
+const { Argument } = require('./lib/argument.js');
+const { Command } = require('./lib/command.js');
+const { CommanderError, InvalidArgumentError } = require('./lib/error.js');
+const { Help } = require('./lib/help.js');
+const { Option } = require('./lib/option.js');
+
+exports.program = new Command();
+
+exports.createCommand = (name) => new Command(name);
+exports.createOption = (flags, description) => new Option(flags, description);
+exports.createArgument = (name, description) => new Argument(name, description);
+
+/**
+ * Expose classes
+ */
+
+exports.Command = Command;
+exports.Option = Option;
+exports.Argument = Argument;
+exports.Help = Help;
+
+exports.CommanderError = CommanderError;
+exports.InvalidArgumentError = InvalidArgumentError;
+exports.InvalidOptionArgumentError = InvalidArgumentError; // Deprecated

node_modules/office-addin-lint/node_modules/commander/lib/argument.js

@@ -0,0 +1,149 @@
+const { InvalidArgumentError } = require('./error.js');
+
+class Argument {
+  /**
+   * Initialize a new command argument with the given name and description.
+   * The default is that the argument is required, and you can explicitly
+   * indicate this with <> around the name. Put [] around the name for an optional argument.
+   *
+   * @param {string} name
+   * @param {string} [description]
+   */
+
+  constructor(name, description) {
+    this.description = description || '';
+    this.variadic = false;
+    this.parseArg = undefined;
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.argChoices = undefined;
+
+    switch (name[0]) {
+      case '<': // e.g. <required>
+        this.required = true;
+        this._name = name.slice(1, -1);
+        break;
+      case '[': // e.g. [optional]
+        this.required = false;
+        this._name = name.slice(1, -1);
+        break;
+      default:
+        this.required = true;
+        this._name = name;
+        break;
+    }
+
+    if (this._name.length > 3 && this._name.slice(-3) === '...') {
+      this.variadic = true;
+      this._name = this._name.slice(0, -3);
+    }
+  }
+
+  /**
+   * Return argument name.
+   *
+   * @return {string}
+   */
+
+  name() {
+    return this._name;
+  }
+
+  /**
+   * @package
+   */
+
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+
+    return previous.concat(value);
+  }
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {*} value
+   * @param {string} [description]
+   * @return {Argument}
+   */
+
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  }
+
+  /**
+   * Set the custom handler for processing CLI command arguments into argument values.
+   *
+   * @param {Function} [fn]
+   * @return {Argument}
+   */
+
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  }
+
+  /**
+   * Only allow argument value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Argument}
+   */
+
+  choices(values) {
+    this.argChoices = values.slice();
+    this.parseArg = (arg, previous) => {
+      if (!this.argChoices.includes(arg)) {
+        throw new InvalidArgumentError(
+          `Allowed choices are ${this.argChoices.join(', ')}.`,
+        );
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  }
+
+  /**
+   * Make argument required.
+   *
+   * @returns {Argument}
+   */
+  argRequired() {
+    this.required = true;
+    return this;
+  }
+
+  /**
+   * Make argument optional.
+   *
+   * @returns {Argument}
+   */
+  argOptional() {
+    this.required = false;
+    return this;
+  }
+}
+
+/**
+ * Takes an argument and returns its human readable equivalent for help usage.
+ *
+ * @param {Argument} arg
+ * @return {string}
+ * @private
+ */
+
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name() + (arg.variadic === true ? '...' : '');
+
+  return arg.required ? '<' + nameOutput + '>' : '[' + nameOutput + ']';
+}
+
+exports.Argument = Argument;
+exports.humanReadableArgName = humanReadableArgName;

node_modules/office-addin-lint/node_modules/commander/lib/error.js

@@ -0,0 +1,39 @@
+/**
+ * CommanderError class
+ */
+class CommanderError extends Error {
+  /**
+   * Constructs the CommanderError class
+   * @param {number} exitCode suggested exit code which could be used with process.exit
+   * @param {string} code an id string representing the error
+   * @param {string} message human-readable description of the error
+   */
+  constructor(exitCode, code, message) {
+    super(message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+    this.nestedError = undefined;
+  }
+}
+
+/**
+ * InvalidArgumentError class
+ */
+class InvalidArgumentError extends CommanderError {
+  /**
+   * Constructs the InvalidArgumentError class
+   * @param {string} [message] explanation of why argument is invalid
+   */
+  constructor(message) {
+    super(1, 'commander.invalidArgument', message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+  }
+}
+
+exports.CommanderError = CommanderError;
+exports.InvalidArgumentError = InvalidArgumentError;

node_modules/office-addin-lint/node_modules/commander/lib/help.js

@@ -0,0 +1,709 @@
+const { humanReadableArgName } = require('./argument.js');
+
+/**
+ * TypeScript import types for JSDoc, used by Visual Studio Code IntelliSense and `npm run typescript-checkJS`
+ * https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#import-types
+ * @typedef { import("./argument.js").Argument } Argument
+ * @typedef { import("./command.js").Command } Command
+ * @typedef { import("./option.js").Option } Option
+ */
+
+// Although this is a class, methods are static in style to allow override using subclass or just functions.
+class Help {
+  constructor() {
+    this.helpWidth = undefined;
+    this.minWidthToWrap = 40;
+    this.sortSubcommands = false;
+    this.sortOptions = false;
+    this.showGlobalOptions = false;
+  }
+
+  /**
+   * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
+   * and just before calling `formatHelp()`.
+   *
+   * Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses.
+   *
+   * @param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions
+   */
+  prepareContext(contextOptions) {
+    this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+  }
+
+  /**
+   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Command[]}
+   */
+
+  visibleCommands(cmd) {
+    const visibleCommands = cmd.commands.filter((cmd) => !cmd._hidden);
+    const helpCommand = cmd._getHelpCommand();
+    if (helpCommand && !helpCommand._hidden) {
+      visibleCommands.push(helpCommand);
+    }
+    if (this.sortSubcommands) {
+      visibleCommands.sort((a, b) => {
+        // @ts-ignore: because overloaded return type
+        return a.name().localeCompare(b.name());
+      });
+    }
+    return visibleCommands;
+  }
+
+  /**
+   * Compare options for sort.
+   *
+   * @param {Option} a
+   * @param {Option} b
+   * @returns {number}
+   */
+  compareOptions(a, b) {
+    const getSortKey = (option) => {
+      // WYSIWYG for order displayed in help. Short used for comparison if present. No special handling for negated.
+      return option.short
+        ? option.short.replace(/^-/, '')
+        : option.long.replace(/^--/, '');
+    };
+    return getSortKey(a).localeCompare(getSortKey(b));
+  }
+
+  /**
+   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+   *
+   * @param {Command} cmd
+   * @returns {Option[]}
+   */
+
+  visibleOptions(cmd) {
+    const visibleOptions = cmd.options.filter((option) => !option.hidden);
+    // Built-in help option.
+    const helpOption = cmd._getHelpOption();
+    if (helpOption && !helpOption.hidden) {
+      // Automatically hide conflicting flags. Bit dubious but a historical behaviour that is convenient for single-command programs.
+      const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+      const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+      if (!removeShort && !removeLong) {
+        visibleOptions.push(helpOption); // no changes needed
+      } else if (helpOption.long && !removeLong) {
+        visibleOptions.push(
+          cmd.createOption(helpOption.long, helpOption.description),
+        );
+      } else if (helpOption.short && !removeShort) {
+        visibleOptions.push(
+          cmd.createOption(helpOption.short, helpOption.description),
+        );
+      }
+    }
+    if (this.sortOptions) {
+      visibleOptions.sort(this.compareOptions);
+    }
+    return visibleOptions;
+  }
+
+  /**
+   * Get an array of the visible global options. (Not including help.)
+   *
+   * @param {Command} cmd
+   * @returns {Option[]}
+   */
+
+  visibleGlobalOptions(cmd) {
+    if (!this.showGlobalOptions) return [];
+
+    const globalOptions = [];
+    for (
+      let ancestorCmd = cmd.parent;
+      ancestorCmd;
+      ancestorCmd = ancestorCmd.parent
+    ) {
+      const visibleOptions = ancestorCmd.options.filter(
+        (option) => !option.hidden,
+      );
+      globalOptions.push(...visibleOptions);
+    }
+    if (this.sortOptions) {
+      globalOptions.sort(this.compareOptions);
+    }
+    return globalOptions;
+  }
+
+  /**
+   * Get an array of the arguments if any have a description.
+   *
+   * @param {Command} cmd
+   * @returns {Argument[]}
+   */
+
+  visibleArguments(cmd) {
+    // Side effect! Apply the legacy descriptions before the arguments are displayed.
+    if (cmd._argsDescription) {
+      cmd.registeredArguments.forEach((argument) => {
+        argument.description =
+          argument.description || cmd._argsDescription[argument.name()] || '';
+      });
+    }
+
+    // If there are any arguments with a description then return all the arguments.
+    if (cmd.registeredArguments.find((argument) => argument.description)) {
+      return cmd.registeredArguments;
+    }
+    return [];
+  }
+
+  /**
+   * Get the command term to show in the list of subcommands.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  subcommandTerm(cmd) {
+    // Legacy. Ignores custom usage string, and nested commands.
+    const args = cmd.registeredArguments
+      .map((arg) => humanReadableArgName(arg))
+      .join(' ');
+    return (
+      cmd._name +
+      (cmd._aliases[0] ? '|' + cmd._aliases[0] : '') +
+      (cmd.options.length ? ' [options]' : '') + // simplistic check for non-help option
+      (args ? ' ' + args : '')
+    );
+  }
+
+  /**
+   * Get the option term to show in the list of options.
+   *
+   * @param {Option} option
+   * @returns {string}
+   */
+
+  optionTerm(option) {
+    return option.flags;
+  }
+
+  /**
+   * Get the argument term to show in the list of arguments.
+   *
+   * @param {Argument} argument
+   * @returns {string}
+   */
+
+  argumentTerm(argument) {
+    return argument.name();
+  }
+
+  /**
+   * Get the longest command term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestSubcommandTermLength(cmd, helper) {
+    return helper.visibleCommands(cmd).reduce((max, command) => {
+      return Math.max(
+        max,
+        this.displayWidth(
+          helper.styleSubcommandTerm(helper.subcommandTerm(command)),
+        ),
+      );
+    }, 0);
+  }
+
+  /**
+   * Get the longest option term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestOptionTermLength(cmd, helper) {
+    return helper.visibleOptions(cmd).reduce((max, option) => {
+      return Math.max(
+        max,
+        this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))),
+      );
+    }, 0);
+  }
+
+  /**
+   * Get the longest global option term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestGlobalOptionTermLength(cmd, helper) {
+    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+      return Math.max(
+        max,
+        this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))),
+      );
+    }, 0);
+  }
+
+  /**
+   * Get the longest argument term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  longestArgumentTermLength(cmd, helper) {
+    return helper.visibleArguments(cmd).reduce((max, argument) => {
+      return Math.max(
+        max,
+        this.displayWidth(
+          helper.styleArgumentTerm(helper.argumentTerm(argument)),
+        ),
+      );
+    }, 0);
+  }
+
+  /**
+   * Get the command usage to be displayed at the top of the built-in help.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  commandUsage(cmd) {
+    // Usage
+    let cmdName = cmd._name;
+    if (cmd._aliases[0]) {
+      cmdName = cmdName + '|' + cmd._aliases[0];
+    }
+    let ancestorCmdNames = '';
+    for (
+      let ancestorCmd = cmd.parent;
+      ancestorCmd;
+      ancestorCmd = ancestorCmd.parent
+    ) {
+      ancestorCmdNames = ancestorCmd.name() + ' ' + ancestorCmdNames;
+    }
+    return ancestorCmdNames + cmdName + ' ' + cmd.usage();
+  }
+
+  /**
+   * Get the description for the command.
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  commandDescription(cmd) {
+    // @ts-ignore: because overloaded return type
+    return cmd.description();
+  }
+
+  /**
+   * Get the subcommand summary to show in the list of subcommands.
+   * (Fallback to description for backwards compatibility.)
+   *
+   * @param {Command} cmd
+   * @returns {string}
+   */
+
+  subcommandDescription(cmd) {
+    // @ts-ignore: because overloaded return type
+    return cmd.summary() || cmd.description();
+  }
+
+  /**
+   * Get the option description to show in the list of options.
+   *
+   * @param {Option} option
+   * @return {string}
+   */
+
+  optionDescription(option) {
+    const extraInfo = [];
+
+    if (option.argChoices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,
+      );
+    }
+    if (option.defaultValue !== undefined) {
+      // default for boolean and negated more for programmer than end user,
+      // but show true/false for boolean option as may be for hand-rolled env or config processing.
+      const showDefault =
+        option.required ||
+        option.optional ||
+        (option.isBoolean() && typeof option.defaultValue === 'boolean');
+      if (showDefault) {
+        extraInfo.push(
+          `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`,
+        );
+      }
+    }
+    // preset for boolean and negated are more for programmer than end user
+    if (option.presetArg !== undefined && option.optional) {
+      extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
+    }
+    if (option.envVar !== undefined) {
+      extraInfo.push(`env: ${option.envVar}`);
+    }
+    if (extraInfo.length > 0) {
+      return `${option.description} (${extraInfo.join(', ')})`;
+    }
+
+    return option.description;
+  }
+
+  /**
+   * Get the argument description to show in the list of arguments.
+   *
+   * @param {Argument} argument
+   * @return {string}
+   */
+
+  argumentDescription(argument) {
+    const extraInfo = [];
+    if (argument.argChoices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(', ')}`,
+      );
+    }
+    if (argument.defaultValue !== undefined) {
+      extraInfo.push(
+        `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`,
+      );
+    }
+    if (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(', ')})`;
+      if (argument.description) {
+        return `${argument.description} ${extraDescription}`;
+      }
+      return extraDescription;
+    }
+    return argument.description;
+  }
+
+  /**
+   * Generate the built-in help text.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {string}
+   */
+
+  formatHelp(cmd, helper) {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth ?? 80; // in case prepareContext() was not called
+
+    function callFormatItem(term, description) {
+      return helper.formatItem(term, termWidth, description, helper);
+    }
+
+    // Usage
+    let output = [
+      `${helper.styleTitle('Usage:')} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+      '',
+    ];
+
+    // Description
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+      output = output.concat([
+        helper.boxWrap(
+          helper.styleCommandDescription(commandDescription),
+          helpWidth,
+        ),
+        '',
+      ]);
+    }
+
+    // Arguments
+    const argumentList = helper.visibleArguments(cmd).map((argument) => {
+      return callFormatItem(
+        helper.styleArgumentTerm(helper.argumentTerm(argument)),
+        helper.styleArgumentDescription(helper.argumentDescription(argument)),
+      );
+    });
+    if (argumentList.length > 0) {
+      output = output.concat([
+        helper.styleTitle('Arguments:'),
+        ...argumentList,
+        '',
+      ]);
+    }
+
+    // Options
+    const optionList = helper.visibleOptions(cmd).map((option) => {
+      return callFormatItem(
+        helper.styleOptionTerm(helper.optionTerm(option)),
+        helper.styleOptionDescription(helper.optionDescription(option)),
+      );
+    });
+    if (optionList.length > 0) {
+      output = output.concat([
+        helper.styleTitle('Options:'),
+        ...optionList,
+        '',
+      ]);
+    }
+
+    if (helper.showGlobalOptions) {
+      const globalOptionList = helper
+        .visibleGlobalOptions(cmd)
+        .map((option) => {
+          return callFormatItem(
+            helper.styleOptionTerm(helper.optionTerm(option)),
+            helper.styleOptionDescription(helper.optionDescription(option)),
+          );
+        });
+      if (globalOptionList.length > 0) {
+        output = output.concat([
+          helper.styleTitle('Global Options:'),
+          ...globalOptionList,
+          '',
+        ]);
+      }
+    }
+
+    // Commands
+    const commandList = helper.visibleCommands(cmd).map((cmd) => {
+      return callFormatItem(
+        helper.styleSubcommandTerm(helper.subcommandTerm(cmd)),
+        helper.styleSubcommandDescription(helper.subcommandDescription(cmd)),
+      );
+    });
+    if (commandList.length > 0) {
+      output = output.concat([
+        helper.styleTitle('Commands:'),
+        ...commandList,
+        '',
+      ]);
+    }
+
+    return output.join('\n');
+  }
+
+  /**
+   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+   *
+   * @param {string} str
+   * @returns {number}
+   */
+  displayWidth(str) {
+    return stripColor(str).length;
+  }
+
+  /**
+   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+   *
+   * @param {string} str
+   * @returns {string}
+   */
+  styleTitle(str) {
+    return str;
+  }
+
+  styleUsage(str) {
+    // Usage has lots of parts the user might like to color separately! Assume default usage string which is formed like:
+    //    command subcommand [options] [command] <foo> [bar]
+    return str
+      .split(' ')
+      .map((word) => {
+        if (word === '[options]') return this.styleOptionText(word);
+        if (word === '[command]') return this.styleSubcommandText(word);
+        if (word[0] === '[' || word[0] === '<')
+          return this.styleArgumentText(word);
+        return this.styleCommandText(word); // Restrict to initial words?
+      })
+      .join(' ');
+  }
+  styleCommandDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  styleOptionDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  styleSubcommandDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  styleArgumentDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  styleDescriptionText(str) {
+    return str;
+  }
+  styleOptionTerm(str) {
+    return this.styleOptionText(str);
+  }
+  styleSubcommandTerm(str) {
+    // This is very like usage with lots of parts! Assume default string which is formed like:
+    //    subcommand [options] <foo> [bar]
+    return str
+      .split(' ')
+      .map((word) => {
+        if (word === '[options]') return this.styleOptionText(word);
+        if (word[0] === '[' || word[0] === '<')
+          return this.styleArgumentText(word);
+        return this.styleSubcommandText(word); // Restrict to initial words?
+      })
+      .join(' ');
+  }
+  styleArgumentTerm(str) {
+    return this.styleArgumentText(str);
+  }
+  styleOptionText(str) {
+    return str;
+  }
+  styleArgumentText(str) {
+    return str;
+  }
+  styleSubcommandText(str) {
+    return str;
+  }
+  styleCommandText(str) {
+    return str;
+  }
+
+  /**
+   * Calculate the pad width from the maximum term length.
+   *
+   * @param {Command} cmd
+   * @param {Help} helper
+   * @returns {number}
+   */
+
+  padWidth(cmd, helper) {
+    return Math.max(
+      helper.longestOptionTermLength(cmd, helper),
+      helper.longestGlobalOptionTermLength(cmd, helper),
+      helper.longestSubcommandTermLength(cmd, helper),
+      helper.longestArgumentTermLength(cmd, helper),
+    );
+  }
+
+  /**
+   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
+   *
+   * @param {string} str
+   * @returns {boolean}
+   */
+  preformatted(str) {
+    return /\n[^\S\r\n]/.test(str);
+  }
+
+  /**
+   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+   *
+   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+   *   TTT  DDD DDDD
+   *        DD DDD
+   *
+   * @param {string} term
+   * @param {number} termWidth
+   * @param {string} description
+   * @param {Help} helper
+   * @returns {string}
+   */
+  formatItem(term, termWidth, description, helper) {
+    const itemIndent = 2;
+    const itemIndentStr = ' '.repeat(itemIndent);
+    if (!description) return itemIndentStr + term;
+
+    // Pad the term out to a consistent width, so descriptions are aligned.
+    const paddedTerm = term.padEnd(
+      termWidth + term.length - helper.displayWidth(term),
+    );
+
+    // Format the description.
+    const spacerWidth = 2; // between term and description
+    const helpWidth = this.helpWidth ?? 80; // in case prepareContext() was not called
+    const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+    let formattedDescription;
+    if (
+      remainingWidth < this.minWidthToWrap ||
+      helper.preformatted(description)
+    ) {
+      formattedDescription = description;
+    } else {
+      const wrappedDescription = helper.boxWrap(description, remainingWidth);
+      formattedDescription = wrappedDescription.replace(
+        /\n/g,
+        '\n' + ' '.repeat(termWidth + spacerWidth),
+      );
+    }
+
+    // Construct and overall indent.
+    return (
+      itemIndentStr +
+      paddedTerm +
+      ' '.repeat(spacerWidth) +
+      formattedDescription.replace(/\n/g, `\n${itemIndentStr}`)
+    );
+  }
+
+  /**
+   * Wrap a string at whitespace, preserving existing line breaks.
+   * Wrapping is skipped if the width is less than `minWidthToWrap`.
+   *
+   * @param {string} str
+   * @param {number} width
+   * @returns {string}
+   */
+  boxWrap(str, width) {
+    if (width < this.minWidthToWrap) return str;
+
+    const rawLines = str.split(/\r\n|\n/);
+    // split up text by whitespace
+    const chunkPattern = /[\s]*[^\s]+/g;
+    const wrappedLines = [];
+    rawLines.forEach((line) => {
+      const chunks = line.match(chunkPattern);
+      if (chunks === null) {
+        wrappedLines.push('');
+        return;
+      }
+
+      let sumChunks = [chunks.shift()];
+      let sumWidth = this.displayWidth(sumChunks[0]);
+      chunks.forEach((chunk) => {
+        const visibleWidth = this.displayWidth(chunk);
+        // Accumulate chunks while they fit into width.
+        if (sumWidth + visibleWidth <= width) {
+          sumChunks.push(chunk);
+          sumWidth += visibleWidth;
+          return;
+        }
+        wrappedLines.push(sumChunks.join(''));
+
+        const nextChunk = chunk.trimStart(); // trim space at line break
+        sumChunks = [nextChunk];
+        sumWidth = this.displayWidth(nextChunk);
+      });
+      wrappedLines.push(sumChunks.join(''));
+    });
+
+    return wrappedLines.join('\n');
+  }
+}
+
+/**
+ * Strip style ANSI escape sequences from the string. In particular, SGR (Select Graphic Rendition) codes.
+ *
+ * @param {string} str
+ * @returns {string}
+ * @package
+ */
+
+function stripColor(str) {
+  // eslint-disable-next-line no-control-regex
+  const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+  return str.replace(sgrPattern, '');
+}
+
+exports.Help = Help;
+exports.stripColor = stripColor;

node_modules/office-addin-lint/node_modules/commander/lib/option.js

@@ -0,0 +1,367 @@
+const { InvalidArgumentError } = require('./error.js');
+
+class Option {
+  /**
+   * Initialize a new `Option` with the given `flags` and `description`.
+   *
+   * @param {string} flags
+   * @param {string} [description]
+   */
+
+  constructor(flags, description) {
+    this.flags = flags;
+    this.description = description || '';
+
+    this.required = flags.includes('<'); // A value must be supplied when the option is specified.
+    this.optional = flags.includes('['); // A value is optional when the option is specified.
+    // variadic test ignores <value,...> et al which might be used to describe custom splitting of single argument
+    this.variadic = /\w\.\.\.[>\]]$/.test(flags); // The option can take multiple values.
+    this.mandatory = false; // The option must have a value after parsing, which usually means it must be specified on command line.
+    const optionFlags = splitOptionFlags(flags);
+    this.short = optionFlags.shortFlag; // May be a short flag, undefined, or even a long flag (if option has two long flags).
+    this.long = optionFlags.longFlag;
+    this.negate = false;
+    if (this.long) {
+      this.negate = this.long.startsWith('--no-');
+    }
+    this.defaultValue = undefined;
+    this.defaultValueDescription = undefined;
+    this.presetArg = undefined;
+    this.envVar = undefined;
+    this.parseArg = undefined;
+    this.hidden = false;
+    this.argChoices = undefined;
+    this.conflictsWith = [];
+    this.implied = undefined;
+  }
+
+  /**
+   * Set the default value, and optionally supply the description to be displayed in the help.
+   *
+   * @param {*} value
+   * @param {string} [description]
+   * @return {Option}
+   */
+
+  default(value, description) {
+    this.defaultValue = value;
+    this.defaultValueDescription = description;
+    return this;
+  }
+
+  /**
+   * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+   * The custom processing (parseArg) is called.
+   *
+   * @example
+   * new Option('--color').default('GREYSCALE').preset('RGB');
+   * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+   *
+   * @param {*} arg
+   * @return {Option}
+   */
+
+  preset(arg) {
+    this.presetArg = arg;
+    return this;
+  }
+
+  /**
+   * Add option name(s) that conflict with this option.
+   * An error will be displayed if conflicting options are found during parsing.
+   *
+   * @example
+   * new Option('--rgb').conflicts('cmyk');
+   * new Option('--js').conflicts(['ts', 'jsx']);
+   *
+   * @param {(string | string[])} names
+   * @return {Option}
+   */
+
+  conflicts(names) {
+    this.conflictsWith = this.conflictsWith.concat(names);
+    return this;
+  }
+
+  /**
+   * Specify implied option values for when this option is set and the implied options are not.
+   *
+   * The custom processing (parseArg) is not called on the implied values.
+   *
+   * @example
+   * program
+   *   .addOption(new Option('--log', 'write logging information to file'))
+   *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+   *
+   * @param {object} impliedOptionValues
+   * @return {Option}
+   */
+  implies(impliedOptionValues) {
+    let newImplied = impliedOptionValues;
+    if (typeof impliedOptionValues === 'string') {
+      // string is not documented, but easy mistake and we can do what user probably intended.
+      newImplied = { [impliedOptionValues]: true };
+    }
+    this.implied = Object.assign(this.implied || {}, newImplied);
+    return this;
+  }
+
+  /**
+   * Set environment variable to check for option value.
+   *
+   * An environment variable is only used if when processed the current option value is
+   * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+   *
+   * @param {string} name
+   * @return {Option}
+   */
+
+  env(name) {
+    this.envVar = name;
+    return this;
+  }
+
+  /**
+   * Set the custom handler for processing CLI option arguments into option values.
+   *
+   * @param {Function} [fn]
+   * @return {Option}
+   */
+
+  argParser(fn) {
+    this.parseArg = fn;
+    return this;
+  }
+
+  /**
+   * Whether the option is mandatory and must have a value after parsing.
+   *
+   * @param {boolean} [mandatory=true]
+   * @return {Option}
+   */
+
+  makeOptionMandatory(mandatory = true) {
+    this.mandatory = !!mandatory;
+    return this;
+  }
+
+  /**
+   * Hide option in help.
+   *
+   * @param {boolean} [hide=true]
+   * @return {Option}
+   */
+
+  hideHelp(hide = true) {
+    this.hidden = !!hide;
+    return this;
+  }
+
+  /**
+   * @package
+   */
+
+  _concatValue(value, previous) {
+    if (previous === this.defaultValue || !Array.isArray(previous)) {
+      return [value];
+    }
+
+    return previous.concat(value);
+  }
+
+  /**
+   * Only allow option value to be one of choices.
+   *
+   * @param {string[]} values
+   * @return {Option}
+   */
+
+  choices(values) {
+    this.argChoices = values.slice();
+    this.parseArg = (arg, previous) => {
+      if (!this.argChoices.includes(arg)) {
+        throw new InvalidArgumentError(
+          `Allowed choices are ${this.argChoices.join(', ')}.`,
+        );
+      }
+      if (this.variadic) {
+        return this._concatValue(arg, previous);
+      }
+      return arg;
+    };
+    return this;
+  }
+
+  /**
+   * Return option name.
+   *
+   * @return {string}
+   */
+
+  name() {
+    if (this.long) {
+      return this.long.replace(/^--/, '');
+    }
+    return this.short.replace(/^-/, '');
+  }
+
+  /**
+   * Return option name, in a camelcase format that can be used
+   * as an object attribute key.
+   *
+   * @return {string}
+   */
+
+  attributeName() {
+    if (this.negate) {
+      return camelcase(this.name().replace(/^no-/, ''));
+    }
+    return camelcase(this.name());
+  }
+
+  /**
+   * Check if `arg` matches the short or long flag.
+   *
+   * @param {string} arg
+   * @return {boolean}
+   * @package
+   */
+
+  is(arg) {
+    return this.short === arg || this.long === arg;
+  }
+
+  /**
+   * Return whether a boolean option.
+   *
+   * Options are one of boolean, negated, required argument, or optional argument.
+   *
+   * @return {boolean}
+   * @package
+   */
+
+  isBoolean() {
+    return !this.required && !this.optional && !this.negate;
+  }
+}
+
+/**
+ * This class is to make it easier to work with dual options, without changing the existing
+ * implementation. We support separate dual options for separate positive and negative options,
+ * like `--build` and `--no-build`, which share a single option value. This works nicely for some
+ * use cases, but is tricky for others where we want separate behaviours despite
+ * the single shared option value.
+ */
+class DualOptions {
+  /**
+   * @param {Option[]} options
+   */
+  constructor(options) {
+    this.positiveOptions = new Map();
+    this.negativeOptions = new Map();
+    this.dualOptions = new Set();
+    options.forEach((option) => {
+      if (option.negate) {
+        this.negativeOptions.set(option.attributeName(), option);
+      } else {
+        this.positiveOptions.set(option.attributeName(), option);
+      }
+    });
+    this.negativeOptions.forEach((value, key) => {
+      if (this.positiveOptions.has(key)) {
+        this.dualOptions.add(key);
+      }
+    });
+  }
+
+  /**
+   * Did the value come from the option, and not from possible matching dual option?
+   *
+   * @param {*} value
+   * @param {Option} option
+   * @returns {boolean}
+   */
+  valueFromOption(value, option) {
+    const optionKey = option.attributeName();
+    if (!this.dualOptions.has(optionKey)) return true;
+
+    // Use the value to deduce if (probably) came from the option.
+    const preset = this.negativeOptions.get(optionKey).presetArg;
+    const negativeValue = preset !== undefined ? preset : false;
+    return option.negate === (negativeValue === value);
+  }
+}
+
+/**
+ * Convert string from kebab-case to camelCase.
+ *
+ * @param {string} str
+ * @return {string}
+ * @private
+ */
+
+function camelcase(str) {
+  return str.split('-').reduce((str, word) => {
+    return str + word[0].toUpperCase() + word.slice(1);
+  });
+}
+
+/**
+ * Split the short and long flag out of something like '-m,--mixed <value>'
+ *
+ * @private
+ */
+
+function splitOptionFlags(flags) {
+  let shortFlag;
+  let longFlag;
+  // short flag, single dash and single character
+  const shortFlagExp = /^-[^-]$/;
+  // long flag, double dash and at least one character
+  const longFlagExp = /^--[^-]/;
+
+  const flagParts = flags.split(/[ |,]+/).concat('guard');
+  // Normal is short and/or long.
+  if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
+  if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
+  // Long then short. Rarely used but fine.
+  if (!shortFlag && shortFlagExp.test(flagParts[0]))
+    shortFlag = flagParts.shift();
+  // Allow two long flags, like '--ws, --workspace'
+  // This is the supported way to have a shortish option flag.
+  if (!shortFlag && longFlagExp.test(flagParts[0])) {
+    shortFlag = longFlag;
+    longFlag = flagParts.shift();
+  }
+
+  // Check for unprocessed flag. Fail noisily rather than silently ignore.
+  if (flagParts[0].startsWith('-')) {
+    const unsupportedFlag = flagParts[0];
+    const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+    if (/^-[^-][^-]/.test(unsupportedFlag))
+      throw new Error(
+        `${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`,
+      );
+    if (shortFlagExp.test(unsupportedFlag))
+      throw new Error(`${baseError}
+- too many short flags`);
+    if (longFlagExp.test(unsupportedFlag))
+      throw new Error(`${baseError}
+- too many long flags`);
+
+    throw new Error(`${baseError}
+- unrecognised flag format`);
+  }
+  if (shortFlag === undefined && longFlag === undefined)
+    throw new Error(
+      `option creation failed due to no flags found in '${flags}'.`,
+    );
+
+  return { shortFlag, longFlag };
+}
+
+exports.Option = Option;
+exports.DualOptions = DualOptions;

node_modules/office-addin-lint/node_modules/commander/lib/suggestSimilar.js

@@ -0,0 +1,101 @@
+const maxDistance = 3;
+
+function editDistance(a, b) {
+  // https://en.wikipedia.org/wiki/Damerau–Levenshtein_distance
+  // Calculating optimal string alignment distance, no substring is edited more than once.
+  // (Simple implementation.)
+
+  // Quick early exit, return worst case.
+  if (Math.abs(a.length - b.length) > maxDistance)
+    return Math.max(a.length, b.length);
+
+  // distance between prefix substrings of a and b
+  const d = [];
+
+  // pure deletions turn a into empty string
+  for (let i = 0; i <= a.length; i++) {
+    d[i] = [i];
+  }
+  // pure insertions turn empty string into b
+  for (let j = 0; j <= b.length; j++) {
+    d[0][j] = j;
+  }
+
+  // fill matrix
+  for (let j = 1; j <= b.length; j++) {
+    for (let i = 1; i <= a.length; i++) {
+      let cost = 1;
+      if (a[i - 1] === b[j - 1]) {
+        cost = 0;
+      } else {
+        cost = 1;
+      }
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1, // deletion
+        d[i][j - 1] + 1, // insertion
+        d[i - 1][j - 1] + cost, // substitution
+      );
+      // transposition
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+      }
+    }
+  }
+
+  return d[a.length][b.length];
+}
+
+/**
+ * Find close matches, restricted to same number of edits.
+ *
+ * @param {string} word
+ * @param {string[]} candidates
+ * @returns {string}
+ */
+
+function suggestSimilar(word, candidates) {
+  if (!candidates || candidates.length === 0) return '';
+  // remove possible duplicates
+  candidates = Array.from(new Set(candidates));
+
+  const searchingOptions = word.startsWith('--');
+  if (searchingOptions) {
+    word = word.slice(2);
+    candidates = candidates.map((candidate) => candidate.slice(2));
+  }
+
+  let similar = [];
+  let bestDistance = maxDistance;
+  const minSimilarity = 0.4;
+  candidates.forEach((candidate) => {
+    if (candidate.length <= 1) return; // no one character guesses
+
+    const distance = editDistance(word, candidate);
+    const length = Math.max(word.length, candidate.length);
+    const similarity = (length - distance) / length;
+    if (similarity > minSimilarity) {
+      if (distance < bestDistance) {
+        // better edit distance, throw away previous worse matches
+        bestDistance = distance;
+        similar = [candidate];
+      } else if (distance === bestDistance) {
+        similar.push(candidate);
+      }
+    }
+  });
+
+  similar.sort((a, b) => a.localeCompare(b));
+  if (searchingOptions) {
+    similar = similar.map((candidate) => `--${candidate}`);
+  }
+
+  if (similar.length > 1) {
+    return `\n(Did you mean one of ${similar.join(', ')}?)`;
+  }
+  if (similar.length === 1) {
+    return `\n(Did you mean ${similar[0]}?)`;
+  }
+  return '';
+}
+
+exports.suggestSimilar = suggestSimilar;

node_modules/office-addin-lint/node_modules/commander/package-support.json

@@ -0,0 +1,16 @@
+{
+  "versions": [
+    {
+      "version": "*",
+      "target": {
+        "node": "supported"
+      },
+      "response": {
+        "type": "time-permitting"
+      },
+      "backing": {
+        "npm-funding": true
+      }
+    }
+  ]
+}

node_modules/office-addin-lint/node_modules/commander/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "commander",
+  "version": "13.1.0",
+  "description": "the complete solution for node.js command-line programs",
+  "keywords": [
+    "commander",
+    "command",
+    "option",
+    "parser",
+    "cli",
+    "argument",
+    "args",
+    "argv"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tj/commander.js.git"
+  },
+  "scripts": {
+    "check": "npm run check:type && npm run check:lint && npm run check:format",
+    "check:format": "prettier --check .",
+    "check:lint": "eslint .",
+    "check:type": "npm run check:type:js && npm run check:type:ts",
+    "check:type:ts": "tsd && tsc -p tsconfig.ts.json",
+    "check:type:js": "tsc -p tsconfig.js.json",
+    "fix": "npm run fix:lint && npm run fix:format",
+    "fix:format": "prettier --write .",
+    "fix:lint": "eslint --fix .",
+    "test": "jest && npm run check:type:ts",
+    "test-all": "jest && npm run test-esm && npm run check",
+    "test-esm": "node ./tests/esm-imports-test.mjs"
+  },
+  "files": [
+    "index.js",
+    "lib/*.js",
+    "esm.mjs",
+    "typings/index.d.ts",
+    "typings/esm.d.mts",
+    "package-support.json"
+  ],
+  "type": "commonjs",
+  "main": "./index.js",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./index.js"
+      },
+      "import": {
+        "types": "./typings/esm.d.mts",
+        "default": "./esm.mjs"
+      },
+      "default": "./index.js"
+    },
+    "./esm.mjs": {
+      "types": "./typings/esm.d.mts",
+      "import": "./esm.mjs"
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.4.0",
+    "@types/jest": "^29.2.4",
+    "@types/node": "^22.7.4",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-jest": "^28.3.0",
+    "globals": "^15.7.0",
+    "jest": "^29.3.1",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.0.3",
+    "tsd": "^0.31.0",
+    "typescript": "^5.0.4",
+    "typescript-eslint": "^8.12.2"
+  },
+  "types": "typings/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  },
+  "support": true
+}

node_modules/office-addin-lint/node_modules/commander/typings/esm.d.mts

@@ -0,0 +1,3 @@
+// Just reexport the types from cjs
+// This is a bit indirect. There is not an index.js, but TypeScript will look for index.d.ts for types.
+export * from './index.js';

node_modules/office-addin-lint/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "office-addin-lint",
+  "version": "3.0.3",
+  "description": "Provide eslint and prettier integration",
+  "main": "./lib/main.js",
+  "scripts": {
+    "build": "rimraf lib && concurrently \"tsc -p tsconfig.json\"",
+    "cli": "node lib/cli.js",
+    "lint": "node lib/cli.js check",
+    "lint:fix": "node lib/cli.js fix",
+    "prettier": "node lib/cli.js prettier",
+    "test": "mocha -r ts-node/register test/src/*.ts"
+  },
+  "author": "Office Dev",
+  "license": "MIT",
+  "bin": {
+    "office-addin-lint": "lib/cli.js"
+  },
+  "config": {
+    "lint_files": "src/**/*.{ts,tsx,js,jsx}"
+  },
+  "keywords": [
+    "Office",
+    "Office Add-in"
+  ],
+  "dependencies": {
+    "commander": "^13.0.0",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-office-addins": "^4.0.3",
+    "eslint-plugin-prettier": "^5.1.3",
+    "office-addin-prettier-config": "^2.0.1",
+    "office-addin-usage-data": "^2.0.3",
+    "prettier": "^3.2.5",
+    "typescript-eslint": "^8.4.0"
+  },
+  "devDependencies": {
+    "@types/assert": "^1.5.10",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.12.4",
+    "@types/node-fetch": "^2.6.11",
+    "assert": "^2.1.0",
+    "concurrently": "^9.0.0",
+    "mocha": "^11.0.0",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OfficeDev/Office-Addin-Scripts"
+  },
+  "bugs": {
+    "url": "https://github.com/OfficeDev/Office-Addin-Scripts/issues"
+  },
+  "prettier": "office-addin-prettier-config",
+  "eslintConfig": {
+    "plugins": [
+      "office-addins"
+    ],
+    "extends": [
+      "plugin:office-addins/recommended"
+    ]
+  },
+  "gitHead": "0a83e04842c872533d72b043ebc55e9a6013f34e"
+}

node_modules/office-addin-lint/src/cli.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { Command } from "commander";
+import { logErrorMessage } from "office-addin-usage-data";
+import * as commands from "./commands";
+import * as defaults from "./defaults";
+
+/* global process */
+
+const commander = new Command();
+
+commander.name("office-addin-lint");
+commander.version(process.env.npm_package_version || "(version not available)");
+
+commander
+  .command("check")
+  .option("--files <files>", `Specifies the source files to check. Default: ${defaults.lintFiles}`)
+  .option("--test", "Use the test lint configuration")
+  .description(`Check source files against lint rules.`)
+  .action(commands.lint);
+
+commander
+  .command("fix")
+  .option("--files <files>", `Specifies the source files to fix. Default: ${defaults.lintFiles}`)
+  .option("--test", "Use the test lint configuration")
+  .description(`Apply fixes to source based on lint rules.`)
+  .action(commands.lintFix);
+
+commander
+  .command("prettier")
+  .option("--files <files>", `Specifies which files to use. Default: ${defaults.lintFiles}`)
+  .description(`Make the source prettier.`)
+  .action(commands.prettier);
+
+// if the command is not known, display an error
+commander.on("command:*", function () {
+  logErrorMessage(`The command syntax is not valid.\n`);
+  process.exitCode = 1;
+  commander.help();
+});
+
+if (process.argv.length > 2) {
+  commander.parse(process.argv);
+} else {
+  commander.help();
+}

node_modules/office-addin-lint/src/commands.ts

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { OptionValues } from "commander";
+import { logErrorMessage } from "office-addin-usage-data";
+import * as defaults from "./defaults";
+import { makeFilesPrettier, performLintCheck, performLintFix } from "./lint";
+import { usageDataObject } from "./defaults";
+
+/* global process */
+
+/**
+ * Determines path to files to run lint against. Priority order follows:
+ * 1 --files option passed through cli
+ * 2 lint_files config property in package.json
+ * 3 default location
+ * @param command command options which can contain files
+ */
+function getPathToFiles(options: OptionValues): string {
+  const pathToFiles: any = options.files
+    ? options.files
+    : process.env.npm_package_config_lint_files;
+  return pathToFiles ? pathToFiles : defaults.lintFiles;
+}
+
+export async function lint(options: OptionValues) {
+  try {
+    const pathToFiles: string = getPathToFiles(options);
+    const useTestConfig: boolean = options.test;
+    await performLintCheck(pathToFiles, useTestConfig);
+    usageDataObject.reportSuccess("lint");
+  } catch (err: any) {
+    if (typeof err.status == "number") {
+      process.exitCode = err.status;
+    } else {
+      process.exitCode = defaults.ESLintExitCode.CommandFailed;
+      usageDataObject.reportException("lint", err);
+      logErrorMessage(err);
+    }
+  }
+}
+
+export async function lintFix(options: OptionValues) {
+  try {
+    const pathToFiles: string = getPathToFiles(options);
+    const useTestConfig: boolean = options.test;
+    await performLintFix(pathToFiles, useTestConfig);
+    usageDataObject.reportSuccess("lintFix");
+  } catch (err: any) {
+    if (typeof err.status == "number") {
+      process.exitCode = err.status;
+    } else {
+      process.exitCode = defaults.ESLintExitCode.CommandFailed;
+      usageDataObject.reportException("lintFix", err);
+      logErrorMessage(err);
+    }
+  }
+}
+
+export async function prettier(options: OptionValues) {
+  try {
+    const pathToFiles: string = getPathToFiles(options);
+    await makeFilesPrettier(pathToFiles);
+    usageDataObject.reportSuccess("prettier");
+  } catch (err: any) {
+    if (typeof err.status == "number") {
+      process.exitCode = err.status;
+    } else {
+      process.exitCode = defaults.PrettierExitCode.CommandFailed;
+      usageDataObject.reportException("prettier", err);
+      logErrorMessage(err);
+    }
+  }
+}

node_modules/office-addin-lint/src/defaults.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import {
+  instrumentationKeyForOfficeAddinCLITools,
+  OfficeAddinUsageData,
+} from "office-addin-usage-data";
+
+export const lintFiles = "src/**/*.{ts,tsx,js,jsx}";
+
+export enum ESLintExitCode {
+  NoLintErrors = 0,
+  HasLintError = 1,
+  CommandFailed = 2,
+}
+
+export enum PrettierExitCode {
+  NoFormattingProblems = 0,
+  HasFormattingProblem = 1,
+  CommandFailed = 2,
+}
+
+// Usage data defaults
+export const usageDataObject: OfficeAddinUsageData = new OfficeAddinUsageData({
+  projectName: "office-addin-lint",
+  instrumentationKey: instrumentationKeyForOfficeAddinCLITools,
+  raisePrompt: false,
+});

node_modules/office-addin-lint/src/lint.ts

@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import fs from "fs";
+import path from "path";
+import { usageDataObject, ESLintExitCode, PrettierExitCode } from "./defaults";
+
+/* global process require __dirname */
+
+const eslintPath = require.resolve("eslint");
+const prettierPath = require.resolve("prettier");
+const eslintDir = path.parse(eslintPath).dir;
+const eslintFilePath = path.resolve(eslintDir, "../bin/eslint.js");
+const prettierFilePath = path.resolve(prettierPath, "../bin/prettier.cjs");
+const eslintConfigPath = path.resolve(__dirname, "../config/eslint.config.mjs");
+const eslintTestConfigPath = path.resolve(__dirname, "../config/eslint.config.test.mjs");
+
+function execCommand(command: string) {
+  const execSync = require("child_process").execSync;
+  execSync(command, { stdio: "inherit" });
+}
+
+function normalizeFilePath(filePath: string): string {
+  return filePath.replace(/ /g, "\\ "); // Converting space to '\\'
+}
+
+function getEsLintBaseCommand(useTestConfig: boolean = false): string {
+  const projLintConfig = path.resolve(process.cwd(), "eslint.config.mjs");
+  const prodConfig = fs.existsSync(projLintConfig) ? projLintConfig : eslintConfigPath;
+  const configFilePath = useTestConfig ? eslintTestConfigPath : prodConfig;
+  const eslintBaseCommand: string = `node "${eslintFilePath}" -c "${configFilePath}"`;
+  return eslintBaseCommand;
+}
+
+export function getLintCheckCommand(files: string, useTestConfig: boolean = false): string {
+  const eslintCommand: string = `${getEsLintBaseCommand(useTestConfig)} "${normalizeFilePath(files)}"`;
+  return eslintCommand;
+}
+
+export function performLintCheck(files: string, useTestConfig: boolean = false) {
+  try {
+    const command = getLintCheckCommand(files, useTestConfig);
+    execCommand(command);
+    usageDataObject.reportSuccess("performLintCheck()", { exitCode: ESLintExitCode.NoLintErrors });
+  } catch (err: any) {
+    if (err.status && err.status == ESLintExitCode.HasLintError) {
+      usageDataObject.reportExpectedException("performLintCheck()", err, {
+        exitCode: ESLintExitCode.HasLintError,
+      });
+    } else {
+      usageDataObject.reportException("performLintCheck()", err);
+    }
+    throw err;
+  }
+}
+
+export function getLintFixCommand(files: string, useTestConfig: boolean = false): string {
+  const eslintCommand: string = `${getEsLintBaseCommand(useTestConfig)} --fix ${normalizeFilePath(files)}`;
+  return eslintCommand;
+}
+
+export function performLintFix(files: string, useTestConfig: boolean = false) {
+  try {
+    const command = getLintFixCommand(files, useTestConfig);
+    execCommand(command);
+    usageDataObject.reportSuccess("performLintFix()", { exitCode: ESLintExitCode.NoLintErrors });
+  } catch (err: any) {
+    if (err.status && err.status == ESLintExitCode.HasLintError) {
+      usageDataObject.reportExpectedException("performLintFix()", err, {
+        exitCode: ESLintExitCode.HasLintError,
+      });
+    } else {
+      usageDataObject.reportException("performLintFix()", err);
+    }
+    throw err;
+  }
+}
+
+export function getPrettierCommand(files: string): string {
+  const prettierFixCommand: string = `node ${prettierFilePath} --parser typescript --write ${normalizeFilePath(files)}`;
+  return prettierFixCommand;
+}
+
+export function makeFilesPrettier(files: string) {
+  try {
+    const command = getPrettierCommand(files);
+    execCommand(command);
+    usageDataObject.reportSuccess("makeFilesPrettier()", {
+      exitCode: PrettierExitCode.NoFormattingProblems,
+    });
+  } catch (err: any) {
+    if (err.status && err.status == PrettierExitCode.HasFormattingProblem) {
+      usageDataObject.reportExpectedException("makeFilesPrettier()", err, {
+        exitCode: PrettierExitCode.HasFormattingProblem,
+      });
+    } else {
+      usageDataObject.reportException("makeFilesPrettier()", err);
+    }
+    throw err;
+  }
+}

node_modules/office-addin-lint/src/main.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+export * from "./defaults";
+export * from "./lint";

node_modules/office-addin-lint/test/src/test.ts

@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import assert from "assert";
+import { describe, it } from "mocha";
+import * as prettierLint from "../../src/lint";
+
+describe("test cases", function () {
+  it("eslint and prettier commands", async function () {
+    const inputFile = "./test/cases/basic/functions.ts";
+    const lintExpectedCommand = "./test/cases/basic/functions.ts";
+    const lintFixExpectedCommand = "--fix ./test/cases/basic/functions.ts";
+    const prettierExpectedCommand = "--parser typescript --write ./test/cases/basic/functions.ts";
+    const lintExpectedTestConfig = "eslint.config.test.mjs";
+
+    const lintCheckCommand = prettierLint.getLintCheckCommand(inputFile);
+    assert.strictEqual(
+      lintCheckCommand.indexOf(lintExpectedCommand) > 0,
+      true,
+      "Lint command does not match expected value."
+    );
+
+    const lintCheckConfig = prettierLint.getLintCheckCommand(inputFile, true);
+    assert.strictEqual(
+      lintCheckConfig.indexOf(lintExpectedTestConfig) > 0,
+      true,
+      "Lint test command does not match expected value."
+    );
+
+    const lintFixCommand = prettierLint.getLintFixCommand(inputFile);
+    assert.strictEqual(
+      lintFixCommand.indexOf(lintFixExpectedCommand) > 0,
+      true,
+      "Lint fix command does not match expected value."
+    );
+
+    const prettierCommand = prettierLint.getPrettierCommand(inputFile);
+    assert.strictEqual(
+      prettierCommand.indexOf(prettierExpectedCommand) > 0,
+      true,
+      "Prettier command does not match expected value."
+    );
+  });
+
+  it("spaces in filename", async function () {
+    const inputFile = "./test/cases/basic/functions with space.ts";
+    const lintExpectedCommand = "./test/cases/basic/functions\\ with\\ space.ts";
+    const lintFixExpectedCommand = "--fix ./test/cases/basic/functions\\ with\\ space.ts";
+    const prettierExpectedCommand = "--parser typescript --write ./test/cases/basic/functions\\ with\\ space.ts";
+
+    const lintCheckCommand = prettierLint.getLintCheckCommand(inputFile);
+    assert.strictEqual(
+      lintCheckCommand.indexOf(lintExpectedCommand) > 0,
+      true,
+      "Lint command does not match expected value."
+    );
+
+    const lintFixCommand = prettierLint.getLintFixCommand(inputFile);
+    assert.strictEqual(
+      lintFixCommand.indexOf(lintFixExpectedCommand) > 0,
+      true,
+      "Lint fix command does not match expected value."
+    );
+
+    const prettierCommand = prettierLint.getPrettierCommand(inputFile);
+    assert.strictEqual(
+      prettierCommand.indexOf(prettierExpectedCommand) > 0,
+      true,
+      "Prettier command does not match expected value."
+    );
+  });
+
+  it("spaces in filepath", async function () {
+    const inputFile = "./test/cases/basic with space/functions.ts";
+    const lintExpectedCommand = "./test/cases/basic\\ with\\ space/functions.ts";
+    const lintFixExpectedCommand = "--fix ./test/cases/basic\\ with\\ space/functions.ts";
+    const prettierExpectedCommand = "--parser typescript --write ./test/cases/basic\\ with\\ space/functions.ts";
+
+    const lintCheckCommand = prettierLint.getLintCheckCommand(inputFile);
+    assert.strictEqual(
+      lintCheckCommand.indexOf(lintExpectedCommand) > 0,
+      true,
+      "Lint command does not match expected value."
+    );
+
+    const lintFixCommand = prettierLint.getLintFixCommand(inputFile);
+    assert.strictEqual(
+      lintFixCommand.indexOf(lintFixExpectedCommand) > 0,
+      true,
+      "Lint fix command does not match expected value."
+    );
+
+    const prettierCommand = prettierLint.getPrettierCommand(inputFile);
+    assert.strictEqual(
+      prettierCommand.indexOf(prettierExpectedCommand) > 0,
+      true,
+      "Prettier command does not match expected value."
+    );
+  });
+});

node_modules/office-addin-lint/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "lib",
+    "skipLibCheck": true,
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "lib", "test/cases/**/*"]
+}