diff --git a/frontend/release/analysis-logs/lint.sarif b/frontend/release/analysis-logs/lint.sarif deleted file mode 100644 index 818748d..0000000 --- a/frontend/release/analysis-logs/lint.sarif +++ /dev/null @@ -1,17 +0,0 @@ -{ - "version": "2.1.0", - "$schema": "http://json.schemastore.org/sarif-2.1.0-rtm.5", - "runs": [ - { - "tool": { - "driver": { - "name": "ESLint", - "informationUri": "https://eslint.org", - "version": "8.57.1", - "rules": [] - } - }, - "results": [] - } - ] -} \ No newline at end of file diff --git a/frontend/release/assets/ApprovalAdminWebPartStrings_en-us_3bd812ceda191f7235a1db0c41d7c3a7.js b/frontend/release/assets/ApprovalAdminWebPartStrings_en-us.js similarity index 100% rename from frontend/release/assets/ApprovalAdminWebPartStrings_en-us_3bd812ceda191f7235a1db0c41d7c3a7.js rename to frontend/release/assets/ApprovalAdminWebPartStrings_en-us.js diff --git a/frontend/release/assets/approval-admin-web-part.js b/frontend/release/assets/approval-admin-web-part.js new file mode 100644 index 0000000..9ceba39 --- /dev/null +++ b/frontend/release/assets/approval-admin-web-part.js @@ -0,0 +1,5560 @@ +(()=>{ var __RUSHSTACK_CURRENT_SCRIPT__ = document.currentScript; define("4825e72c-4ff3-479e-917e-f6b04e003a82_0.0.1", ["react","react-dom","@microsoft/sp-core-library","@microsoft/sp-property-pane","@microsoft/sp-webpart-base","ApprovalAdminWebPartStrings","@microsoft/sp-lodash-subset"], (__WEBPACK_EXTERNAL_MODULE__959__, __WEBPACK_EXTERNAL_MODULE__398__, __WEBPACK_EXTERNAL_MODULE__676__, __WEBPACK_EXTERNAL_MODULE__877__, __WEBPACK_EXTERNAL_MODULE__642__, __WEBPACK_EXTERNAL_MODULE__937__, __WEBPACK_EXTERNAL_MODULE__529__) => { return /******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 845: +/*!*****************************************************************************!*\ + !*** ./lib/webparts/approvalAdmin/components/ApprovalAdmin.module.scss.css ***! + \*****************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _node_modules_microsoft_sp_css_loader_node_modules_microsoft_load_themed_styles_lib_es6_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../../node_modules/@microsoft/sp-css-loader/node_modules/@microsoft/load-themed-styles/lib-es6/index.js */ 323); +// Imports + + +_node_modules_microsoft_sp_css_loader_node_modules_microsoft_load_themed_styles_lib_es6_index_js__WEBPACK_IMPORTED_MODULE_0__.loadStyles(".approvalAdmin_c54326b8{color:\"[theme:bodyText, default: #323130]\";color:var(--bodyText);overflow:hidden;padding:1em}.approvalAdmin_c54326b8.teams_c54326b8{font-family:Segoe UI,-apple-system,BlinkMacSystemFont,Roboto,Helvetica Neue,sans-serif}.welcome_c54326b8{text-align:center}.welcomeImage_c54326b8{max-width:420px;width:100%}.links_c54326b8 a{color:\"[theme:link, default:#03787c]\";color:var(--link);text-decoration:none}.links_c54326b8 a:hover{color:\"[theme:linkHovered, default: #014446]\";color:var(--linkHovered);text-decoration:underline}", true); + +// Exports +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({ + approvalAdmin: "approvalAdmin_c54326b8", + teams: "teams_c54326b8", + welcome: "welcome_c54326b8", + welcomeImage: "welcomeImage_c54326b8", + links: "links_c54326b8" +}); + + +/***/ }), + +/***/ 403: +/*!************************************************************!*\ + !*** ./lib/webparts/approvalAdmin/ApprovalAdminWebPart.js ***! + \************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! tslib */ 196); +/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ 959); +/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react-dom */ 398); +/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react_dom__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _microsoft_sp_core_library__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @microsoft/sp-core-library */ 676); +/* harmony import */ var _microsoft_sp_core_library__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_microsoft_sp_core_library__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var _microsoft_sp_property_pane__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @microsoft/sp-property-pane */ 877); +/* harmony import */ var _microsoft_sp_property_pane__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_microsoft_sp_property_pane__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _microsoft_sp_webpart_base__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @microsoft/sp-webpart-base */ 642); +/* harmony import */ var _microsoft_sp_webpart_base__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_microsoft_sp_webpart_base__WEBPACK_IMPORTED_MODULE_4__); +/* harmony import */ var ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ApprovalAdminWebPartStrings */ 937); +/* harmony import */ var ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__); +/* harmony import */ var _components_ApprovalAdmin__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./components/ApprovalAdmin */ 867); + + + + + + + + +var ApprovalAdminWebPart = /** @class */ (function (_super) { + (0,tslib__WEBPACK_IMPORTED_MODULE_7__.__extends)(ApprovalAdminWebPart, _super); + function ApprovalAdminWebPart() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this._isDarkTheme = false; + _this._environmentMessage = ''; + return _this; + } + ApprovalAdminWebPart.prototype.render = function () { + var element = react__WEBPACK_IMPORTED_MODULE_0__.createElement(_components_ApprovalAdmin__WEBPACK_IMPORTED_MODULE_6__["default"], { + description: this.properties.description, + isDarkTheme: this._isDarkTheme, + environmentMessage: this._environmentMessage, + hasTeamsContext: !!this.context.sdks.microsoftTeams, + userDisplayName: this.context.pageContext.user.displayName + }); + react_dom__WEBPACK_IMPORTED_MODULE_1__.render(element, this.domElement); + }; + ApprovalAdminWebPart.prototype.onInit = function () { + var _this = this; + return this._getEnvironmentMessage().then(function (message) { + _this._environmentMessage = message; + }); + }; + ApprovalAdminWebPart.prototype._getEnvironmentMessage = function () { + var _this = this; + if (!!this.context.sdks.microsoftTeams) { // running in Teams, office.com or Outlook + return this.context.sdks.microsoftTeams.teamsJs.app.getContext() + .then(function (context) { + var environmentMessage = ''; + switch (context.app.host.name) { + case 'Office': // running in Office + environmentMessage = _this.context.isServedFromLocalhost ? ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppLocalEnvironmentOffice : ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppOfficeEnvironment; + break; + case 'Outlook': // running in Outlook + environmentMessage = _this.context.isServedFromLocalhost ? ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppLocalEnvironmentOutlook : ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppOutlookEnvironment; + break; + case 'Teams': // running in Teams + case 'TeamsModern': + environmentMessage = _this.context.isServedFromLocalhost ? ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppLocalEnvironmentTeams : ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppTeamsTabEnvironment; + break; + default: + environmentMessage = ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.UnknownEnvironment; + } + return environmentMessage; + }); + } + return Promise.resolve(this.context.isServedFromLocalhost ? ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppLocalEnvironmentSharePoint : ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.AppSharePointEnvironment); + }; + ApprovalAdminWebPart.prototype.onThemeChanged = function (currentTheme) { + if (!currentTheme) { + return; + } + this._isDarkTheme = !!currentTheme.isInverted; + var semanticColors = currentTheme.semanticColors; + if (semanticColors) { + this.domElement.style.setProperty('--bodyText', semanticColors.bodyText || null); + this.domElement.style.setProperty('--link', semanticColors.link || null); + this.domElement.style.setProperty('--linkHovered', semanticColors.linkHovered || null); + } + }; + ApprovalAdminWebPart.prototype.onDispose = function () { + react_dom__WEBPACK_IMPORTED_MODULE_1__.unmountComponentAtNode(this.domElement); + }; + Object.defineProperty(ApprovalAdminWebPart.prototype, "dataVersion", { + get: function () { + return _microsoft_sp_core_library__WEBPACK_IMPORTED_MODULE_2__.Version.parse('1.0'); + }, + enumerable: false, + configurable: true + }); + ApprovalAdminWebPart.prototype.getPropertyPaneConfiguration = function () { + return { + pages: [ + { + header: { + description: ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.PropertyPaneDescription + }, + groups: [ + { + groupName: ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.BasicGroupName, + groupFields: [ + (0,_microsoft_sp_property_pane__WEBPACK_IMPORTED_MODULE_3__.PropertyPaneTextField)('description', { + label: ApprovalAdminWebPartStrings__WEBPACK_IMPORTED_MODULE_5__.DescriptionFieldLabel + }) + ] + } + ] + } + ] + }; + }; + return ApprovalAdminWebPart; +}(_microsoft_sp_webpart_base__WEBPACK_IMPORTED_MODULE_4__.BaseClientSideWebPart)); +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ApprovalAdminWebPart); + + +/***/ }), + +/***/ 867: +/*!****************************************************************!*\ + !*** ./lib/webparts/approvalAdmin/components/ApprovalAdmin.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! tslib */ 196); +/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ 959); +/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _ApprovalAdmin_module_scss__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ApprovalAdmin.module.scss */ 845); +/* harmony import */ var _microsoft_sp_lodash_subset__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @microsoft/sp-lodash-subset */ 529); +/* harmony import */ var _microsoft_sp_lodash_subset__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_microsoft_sp_lodash_subset__WEBPACK_IMPORTED_MODULE_2__); + + + + +var ApprovalAdmin = /** @class */ (function (_super) { + (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__extends)(ApprovalAdmin, _super); + function ApprovalAdmin() { + return _super !== null && _super.apply(this, arguments) || this; + } + ApprovalAdmin.prototype.render = function () { + var _a = this.props, description = _a.description, isDarkTheme = _a.isDarkTheme, environmentMessage = _a.environmentMessage, hasTeamsContext = _a.hasTeamsContext, userDisplayName = _a.userDisplayName; + return (react__WEBPACK_IMPORTED_MODULE_0__.createElement("section", { className: "".concat(_ApprovalAdmin_module_scss__WEBPACK_IMPORTED_MODULE_1__["default"].approvalAdmin, " ").concat(hasTeamsContext ? _ApprovalAdmin_module_scss__WEBPACK_IMPORTED_MODULE_1__["default"].teams : '') }, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("div", { className: _ApprovalAdmin_module_scss__WEBPACK_IMPORTED_MODULE_1__["default"].welcome }, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("img", { alt: "", src: isDarkTheme ? __webpack_require__(/*! ../assets/welcome-dark.png */ 91) : __webpack_require__(/*! ../assets/welcome-light.png */ 459), className: _ApprovalAdmin_module_scss__WEBPACK_IMPORTED_MODULE_1__["default"].welcomeImage }), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("h2", null, + "Well done, ", + (0,_microsoft_sp_lodash_subset__WEBPACK_IMPORTED_MODULE_2__.escape)(userDisplayName), + "!"), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("div", null, environmentMessage), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("div", null, + "Web part property value: ", + react__WEBPACK_IMPORTED_MODULE_0__.createElement("strong", null, (0,_microsoft_sp_lodash_subset__WEBPACK_IMPORTED_MODULE_2__.escape)(description)))), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("div", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("h3", null, "Welcome to SharePoint Framework!"), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("p", null, "The SharePoint Framework (SPFx) is a extensibility model for Microsoft Viva, Microsoft Teams and SharePoint. It's the easiest way to extend Microsoft 365 with automatic Single Sign On, automatic hosting and industry standard tooling."), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("h4", null, "Learn more about SPFx development:"), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("ul", { className: _ApprovalAdmin_module_scss__WEBPACK_IMPORTED_MODULE_1__["default"].links }, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/spfx", target: "_blank", rel: "noreferrer" }, "SharePoint Framework Overview")), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/spfx-yeoman-graph", target: "_blank", rel: "noreferrer" }, "Use Microsoft Graph in your solution")), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/spfx-yeoman-teams", target: "_blank", rel: "noreferrer" }, "Build for Microsoft Teams using SharePoint Framework")), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/spfx-yeoman-viva", target: "_blank", rel: "noreferrer" }, "Build for Microsoft Viva Connections using SharePoint Framework")), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/spfx-yeoman-store", target: "_blank", rel: "noreferrer" }, "Publish SharePoint Framework applications to the marketplace")), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/spfx-yeoman-api", target: "_blank", rel: "noreferrer" }, "SharePoint Framework API reference")), + react__WEBPACK_IMPORTED_MODULE_0__.createElement("li", null, + react__WEBPACK_IMPORTED_MODULE_0__.createElement("a", { href: "https://aka.ms/m365pnp", target: "_blank", rel: "noreferrer" }, "Microsoft 365 Developer Community")))))); + }; + return ApprovalAdmin; +}(react__WEBPACK_IMPORTED_MODULE_0__.Component)); +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ApprovalAdmin); + + +/***/ }), + +/***/ 323: +/*!***********************************************************************************************************!*\ + !*** ./node_modules/@microsoft/sp-css-loader/node_modules/@microsoft/load-themed-styles/lib-es6/index.js ***! + \***********************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ clearStyles: () => (/* binding */ clearStyles), +/* harmony export */ configureLoadStyles: () => (/* binding */ configureLoadStyles), +/* harmony export */ configureRunMode: () => (/* binding */ configureRunMode), +/* harmony export */ detokenize: () => (/* binding */ detokenize), +/* harmony export */ flush: () => (/* binding */ flush), +/* harmony export */ loadStyles: () => (/* binding */ loadStyles), +/* harmony export */ loadTheme: () => (/* binding */ loadTheme), +/* harmony export */ splitStyles: () => (/* binding */ splitStyles) +/* harmony export */ }); +// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license. +// See LICENSE in the project root for license information. +var __assign = (undefined && undefined.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +// Store the theming state in __themeState__ global scope for reuse in the case of duplicate +// load-themed-styles hosted on the page. +var _root = typeof window === 'undefined' ? __webpack_require__.g : window; // eslint-disable-line @typescript-eslint/no-explicit-any +// Nonce string to inject into script tag if one provided. This is used in CSP (Content Security Policy). +var _styleNonce = _root && _root.CSPSettings && _root.CSPSettings.nonce; +var _themeState = initializeThemeState(); +/** + * Matches theming tokens. For example, "[theme: themeSlotName, default: #FFF]" (including the quotes). + */ +var _themeTokenRegex = /[\'\"]\[theme:\s*(\w+)\s*(?:\,\s*default:\s*([\\"\']?[\.\,\(\)\#\-\s\w]*[\.\,\(\)\#\-\w][\"\']?))?\s*\][\'\"]/g; +var now = function () { + return typeof performance !== 'undefined' && !!performance.now ? performance.now() : Date.now(); +}; +function measure(func) { + var start = now(); + func(); + var end = now(); + _themeState.perf.duration += end - start; +} +/** + * initialize global state object + */ +function initializeThemeState() { + var state = _root.__themeState__ || { + theme: undefined, + lastStyleElement: undefined, + registeredStyles: [] + }; + if (!state.runState) { + state = __assign(__assign({}, state), { perf: { + count: 0, + duration: 0 + }, runState: { + flushTimer: 0, + mode: 0 /* Mode.sync */, + buffer: [] + } }); + } + if (!state.registeredThemableStyles) { + state = __assign(__assign({}, state), { registeredThemableStyles: [] }); + } + _root.__themeState__ = state; + return state; +} +/** + * Loads a set of style text. If it is registered too early, we will register it when the window.load + * event is fired. + * @param {string | ThemableArray} styles Themable style text to register. + * @param {boolean} loadAsync When true, always load styles in async mode, irrespective of current sync mode. + */ +function loadStyles(styles, loadAsync) { + if (loadAsync === void 0) { loadAsync = false; } + measure(function () { + var styleParts = Array.isArray(styles) ? styles : splitStyles(styles); + var _a = _themeState.runState, mode = _a.mode, buffer = _a.buffer, flushTimer = _a.flushTimer; + if (loadAsync || mode === 1 /* Mode.async */) { + buffer.push(styleParts); + if (!flushTimer) { + _themeState.runState.flushTimer = asyncLoadStyles(); + } + } + else { + applyThemableStyles(styleParts); + } + }); +} +/** + * Allows for customizable loadStyles logic. e.g. for server side rendering application + * @param {(processedStyles: string, rawStyles?: string | ThemableArray) => void} + * a loadStyles callback that gets called when styles are loaded or reloaded + */ +function configureLoadStyles(loadStylesFn) { + _themeState.loadStyles = loadStylesFn; +} +/** + * Configure run mode of load-themable-styles + * @param mode load-themable-styles run mode, async or sync + */ +function configureRunMode(mode) { + _themeState.runState.mode = mode; +} +/** + * external code can call flush to synchronously force processing of currently buffered styles + */ +function flush() { + measure(function () { + var styleArrays = _themeState.runState.buffer.slice(); + _themeState.runState.buffer = []; + var mergedStyleArray = [].concat.apply([], styleArrays); + if (mergedStyleArray.length > 0) { + applyThemableStyles(mergedStyleArray); + } + }); +} +/** + * register async loadStyles + */ +function asyncLoadStyles() { + return setTimeout(function () { + _themeState.runState.flushTimer = 0; + flush(); + }, 0); +} +/** + * Loads a set of style text. If it is registered too early, we will register it when the window.load event + * is fired. + * @param {string} styleText Style to register. + * @param {IStyleRecord} styleRecord Existing style record to re-apply. + */ +function applyThemableStyles(stylesArray, styleRecord) { + if (_themeState.loadStyles) { + _themeState.loadStyles(resolveThemableArray(stylesArray).styleString, stylesArray); + } + else { + registerStyles(stylesArray); + } +} +/** + * Registers a set theme tokens to find and replace. If styles were already registered, they will be + * replaced. + * @param {theme} theme JSON object of theme tokens to values. + */ +function loadTheme(theme) { + _themeState.theme = theme; + // reload styles. + reloadStyles(); +} +/** + * Clear already registered style elements and style records in theme_State object + * @param option - specify which group of registered styles should be cleared. + * Default to be both themable and non-themable styles will be cleared + */ +function clearStyles(option) { + if (option === void 0) { option = 3 /* ClearStyleOptions.all */; } + if (option === 3 /* ClearStyleOptions.all */ || option === 2 /* ClearStyleOptions.onlyNonThemable */) { + clearStylesInternal(_themeState.registeredStyles); + _themeState.registeredStyles = []; + } + if (option === 3 /* ClearStyleOptions.all */ || option === 1 /* ClearStyleOptions.onlyThemable */) { + clearStylesInternal(_themeState.registeredThemableStyles); + _themeState.registeredThemableStyles = []; + } +} +function clearStylesInternal(records) { + records.forEach(function (styleRecord) { + var styleElement = styleRecord && styleRecord.styleElement; + if (styleElement && styleElement.parentElement) { + styleElement.parentElement.removeChild(styleElement); + } + }); +} +/** + * Reloads styles. + */ +function reloadStyles() { + if (_themeState.theme) { + var themableStyles = []; + for (var _i = 0, _a = _themeState.registeredThemableStyles; _i < _a.length; _i++) { + var styleRecord = _a[_i]; + themableStyles.push(styleRecord.themableStyle); + } + if (themableStyles.length > 0) { + clearStyles(1 /* ClearStyleOptions.onlyThemable */); + applyThemableStyles([].concat.apply([], themableStyles)); + } + } +} +/** + * Find theme tokens and replaces them with provided theme values. + * @param {string} styles Tokenized styles to fix. + */ +function detokenize(styles) { + if (styles) { + styles = resolveThemableArray(splitStyles(styles)).styleString; + } + return styles; +} +/** + * Resolves ThemingInstruction objects in an array and joins the result into a string. + * @param {ThemableArray} splitStyleArray ThemableArray to resolve and join. + */ +function resolveThemableArray(splitStyleArray) { + var theme = _themeState.theme; + var themable = false; + // Resolve the array of theming instructions to an array of strings. + // Then join the array to produce the final CSS string. + var resolvedArray = (splitStyleArray || []).map(function (currentValue) { + var themeSlot = currentValue.theme; + if (themeSlot) { + themable = true; + // A theming annotation. Resolve it. + var themedValue = theme ? theme[themeSlot] : undefined; + var defaultValue = currentValue.defaultValue || 'inherit'; + // Warn to console if we hit an unthemed value even when themes are provided, but only if "DEBUG" is true. + // Allow the themedValue to be undefined to explicitly request the default value. + if (theme && + !themedValue && + console && + !(themeSlot in theme) && + "boolean" !== 'undefined' && + true) { + console.warn("Theming value not provided for \"".concat(themeSlot, "\". Falling back to \"").concat(defaultValue, "\".")); + } + return themedValue || defaultValue; + } + else { + // A non-themable string. Preserve it. + return currentValue.rawString; + } + }); + return { + styleString: resolvedArray.join(''), + themable: themable + }; +} +/** + * Split tokenized CSS into an array of strings and theme specification objects + * @param {string} styles Tokenized styles to split. + */ +function splitStyles(styles) { + var result = []; + if (styles) { + var pos = 0; // Current position in styles. + var tokenMatch = void 0; + while ((tokenMatch = _themeTokenRegex.exec(styles))) { + var matchIndex = tokenMatch.index; + if (matchIndex > pos) { + result.push({ + rawString: styles.substring(pos, matchIndex) + }); + } + result.push({ + theme: tokenMatch[1], + defaultValue: tokenMatch[2] // May be undefined + }); + // index of the first character after the current match + pos = _themeTokenRegex.lastIndex; + } + // Push the rest of the string after the last match. + result.push({ + rawString: styles.substring(pos) + }); + } + return result; +} +/** + * Registers a set of style text. If it is registered too early, we will register it when the + * window.load event is fired. + * @param {ThemableArray} styleArray Array of IThemingInstruction objects to register. + * @param {IStyleRecord} styleRecord May specify a style Element to update. + */ +function registerStyles(styleArray) { + if (typeof document === 'undefined') { + return; + } + var head = document.getElementsByTagName('head')[0]; + var styleElement = document.createElement('style'); + var _a = resolveThemableArray(styleArray), styleString = _a.styleString, themable = _a.themable; + styleElement.setAttribute('data-load-themed-styles', 'true'); + if (_styleNonce) { + styleElement.setAttribute('nonce', _styleNonce); + } + styleElement.appendChild(document.createTextNode(styleString)); + _themeState.perf.count++; + head.appendChild(styleElement); + var ev = document.createEvent('HTMLEvents'); + ev.initEvent('styleinsert', true /* bubbleEvent */, false /* cancelable */); + ev.args = { + newStyle: styleElement + }; + document.dispatchEvent(ev); + var record = { + styleElement: styleElement, + themableStyle: styleArray + }; + if (themable) { + _themeState.registeredThemableStyles.push(record); + } + else { + _themeState.registeredStyles.push(record); + } +} + + +/***/ }), + +/***/ 223: +/*!***************************************************!*\ + !*** ./node_modules/ansi-html-community/index.js ***! + \***************************************************/ +/***/ ((module) => { + +"use strict"; + + +module.exports = ansiHTML + +// Reference to https://github.com/sindresorhus/ansi-regex +var _regANSI = /(?:(?:\u001b\[)|\u009b)(?:(?:[0-9]{1,3})?(?:(?:;[0-9]{0,3})*)?[A-M|f-m])|\u001b[A-M]/ + +var _defColors = { + reset: ['fff', '000'], // [FOREGROUD_COLOR, BACKGROUND_COLOR] + black: '000', + red: 'ff0000', + green: '209805', + yellow: 'e8bf03', + blue: '0000ff', + magenta: 'ff00ff', + cyan: '00ffee', + lightgrey: 'f0f0f0', + darkgrey: '888' +} +var _styles = { + 30: 'black', + 31: 'red', + 32: 'green', + 33: 'yellow', + 34: 'blue', + 35: 'magenta', + 36: 'cyan', + 37: 'lightgrey' +} +var _openTags = { + '1': 'font-weight:bold', // bold + '2': 'opacity:0.5', // dim + '3': '', // italic + '4': '', // underscore + '8': 'display:none', // hidden + '9': '' // delete +} +var _closeTags = { + '23': '', // reset italic + '24': '', // reset underscore + '29': '' // reset delete +} + +;[0, 21, 22, 27, 28, 39, 49].forEach(function (n) { + _closeTags[n] = '' +}) + +/** + * Converts text with ANSI color codes to HTML markup. + * @param {String} text + * @returns {*} + */ +function ansiHTML (text) { + // Returns the text if the string has no ANSI escape code. + if (!_regANSI.test(text)) { + return text + } + + // Cache opened sequence. + var ansiCodes = [] + // Replace with markup. + var ret = text.replace(/\033\[(\d+)m/g, function (match, seq) { + var ot = _openTags[seq] + if (ot) { + // If current sequence has been opened, close it. + if (!!~ansiCodes.indexOf(seq)) { // eslint-disable-line no-extra-boolean-cast + ansiCodes.pop() + return '' + } + // Open tag. + ansiCodes.push(seq) + return ot[0] === '<' ? ot : '' + } + + var ct = _closeTags[seq] + if (ct) { + // Pop sequence + ansiCodes.pop() + return ct + } + return '' + }) + + // Make sure tags are closed. + var l = ansiCodes.length + ;(l > 0) && (ret += Array(l + 1).join('')) + + return ret +} + +/** + * Customize colors. + * @param {Object} colors reference to _defColors + */ +ansiHTML.setColors = function (colors) { + if (typeof colors !== 'object') { + throw new Error('`colors` parameter must be an Object.') + } + + var _finalColors = {} + for (var key in _defColors) { + var hex = colors.hasOwnProperty(key) ? colors[key] : null + if (!hex) { + _finalColors[key] = _defColors[key] + continue + } + if ('reset' === key) { + if (typeof hex === 'string') { + hex = [hex] + } + if (!Array.isArray(hex) || hex.length === 0 || hex.some(function (h) { + return typeof h !== 'string' + })) { + throw new Error('The value of `' + key + '` property must be an Array and each item could only be a hex string, e.g.: FF0000') + } + var defHexColor = _defColors[key] + if (!hex[0]) { + hex[0] = defHexColor[0] + } + if (hex.length === 1 || !hex[1]) { + hex = [hex[0]] + hex.push(defHexColor[1]) + } + + hex = hex.slice(0, 2) + } else if (typeof hex !== 'string') { + throw new Error('The value of `' + key + '` property must be a hex string, e.g.: FF0000') + } + _finalColors[key] = hex + } + _setTags(_finalColors) +} + +/** + * Reset colors. + */ +ansiHTML.reset = function () { + _setTags(_defColors) +} + +/** + * Expose tags, including open and close. + * @type {Object} + */ +ansiHTML.tags = {} + +if (Object.defineProperty) { + Object.defineProperty(ansiHTML.tags, 'open', { + get: function () { return _openTags } + }) + Object.defineProperty(ansiHTML.tags, 'close', { + get: function () { return _closeTags } + }) +} else { + ansiHTML.tags.open = _openTags + ansiHTML.tags.close = _closeTags +} + +function _setTags (colors) { + // reset all + _openTags['0'] = 'font-weight:normal;opacity:1;color:#' + colors.reset[0] + ';background:#' + colors.reset[1] + // inverse + _openTags['7'] = 'color:#' + colors.reset[1] + ';background:#' + colors.reset[0] + // dark grey + _openTags['90'] = 'color:#' + colors.darkgrey + + for (var code in _styles) { + var color = _styles[code] + var oriColor = colors[color] || '000' + _openTags[code] = 'color:#' + oriColor + code = parseInt(code) + _openTags[(code + 10).toString()] = 'background:#' + oriColor + } +} + +ansiHTML.reset() + + +/***/ }), + +/***/ 216: +/*!***************************************!*\ + !*** ./node_modules/events/events.js ***! + \***************************************/ +/***/ ((module) => { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// 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. + + + +var R = typeof Reflect === 'object' ? Reflect : null +var ReflectApply = R && typeof R.apply === 'function' + ? R.apply + : function ReflectApply(target, receiver, args) { + return Function.prototype.apply.call(target, receiver, args); + } + +var ReflectOwnKeys +if (R && typeof R.ownKeys === 'function') { + ReflectOwnKeys = R.ownKeys +} else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target) + .concat(Object.getOwnPropertySymbols(target)); + }; +} else { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target); + }; +} + +function ProcessEmitWarning(warning) { + if (console && console.warn) console.warn(warning); +} + +var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) { + return value !== value; +} + +function EventEmitter() { + EventEmitter.init.call(this); +} +module.exports = EventEmitter; +module.exports.once = once; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._eventsCount = 0; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +var defaultMaxListeners = 10; + +function checkListener(listener) { + if (typeof listener !== 'function') { + throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); + } +} + +Object.defineProperty(EventEmitter, 'defaultMaxListeners', { + enumerable: true, + get: function() { + return defaultMaxListeners; + }, + set: function(arg) { + if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { + throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.'); + } + defaultMaxListeners = arg; + } +}); + +EventEmitter.init = function() { + + if (this._events === undefined || + this._events === Object.getPrototypeOf(this)._events) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + this._maxListeners = this._maxListeners || undefined; +}; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { + if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { + throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.'); + } + this._maxListeners = n; + return this; +}; + +function _getMaxListeners(that) { + if (that._maxListeners === undefined) + return EventEmitter.defaultMaxListeners; + return that._maxListeners; +} + +EventEmitter.prototype.getMaxListeners = function getMaxListeners() { + return _getMaxListeners(this); +}; + +EventEmitter.prototype.emit = function emit(type) { + var args = []; + for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); + var doError = (type === 'error'); + + var events = this._events; + if (events !== undefined) + doError = (doError && events.error === undefined); + else if (!doError) + return false; + + // If there is no 'error' event listener then throw. + if (doError) { + var er; + if (args.length > 0) + er = args[0]; + if (er instanceof Error) { + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event + } + // At least give some kind of context to the user + var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : '')); + err.context = er; + throw err; // Unhandled 'error' event + } + + var handler = events[type]; + + if (handler === undefined) + return false; + + if (typeof handler === 'function') { + ReflectApply(handler, this, args); + } else { + var len = handler.length; + var listeners = arrayClone(handler, len); + for (var i = 0; i < len; ++i) + ReflectApply(listeners[i], this, args); + } + + return true; +}; + +function _addListener(target, type, listener, prepend) { + var m; + var events; + var existing; + + checkListener(listener); + + events = target._events; + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit('newListener', type, + listener.listener ? listener.listener : listener); + + // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + events = target._events; + } + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + existing = events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === 'function') { + // Adding the second element, need to change to array. + existing = events[type] = + prepend ? [listener, existing] : [existing, listener]; + // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + + // Check for listener leak + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + // No error code for this since it is a Warning + // eslint-disable-next-line no-restricted-syntax + var w = new Error('Possible EventEmitter memory leak detected. ' + + existing.length + ' ' + String(type) + ' listeners ' + + 'added. Use emitter.setMaxListeners() to ' + + 'increase limit'); + w.name = 'MaxListenersExceededWarning'; + w.emitter = target; + w.type = type; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + + return target; +} + +EventEmitter.prototype.addListener = function addListener(type, listener) { + return _addListener(this, type, listener, false); +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.prependListener = + function prependListener(type, listener) { + return _addListener(this, type, listener, true); + }; + +function onceWrapper() { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) + return this.listener.call(this.target); + return this.listener.apply(this.target, arguments); + } +} + +function _onceWrap(target, type, listener) { + var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; + var wrapped = onceWrapper.bind(state); + wrapped.listener = listener; + state.wrapFn = wrapped; + return wrapped; +} + +EventEmitter.prototype.once = function once(type, listener) { + checkListener(listener); + this.on(type, _onceWrap(this, type, listener)); + return this; +}; + +EventEmitter.prototype.prependOnceListener = + function prependOnceListener(type, listener) { + checkListener(listener); + this.prependListener(type, _onceWrap(this, type, listener)); + return this; + }; + +// Emits a 'removeListener' event if and only if the listener was removed. +EventEmitter.prototype.removeListener = + function removeListener(type, listener) { + var list, events, position, i, originalListener; + + checkListener(listener); + + events = this._events; + if (events === undefined) + return this; + + list = events[type]; + if (list === undefined) + return this; + + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else { + delete events[type]; + if (events.removeListener) + this.emit('removeListener', type, list.listener || listener); + } + } else if (typeof list !== 'function') { + position = -1; + + for (i = list.length - 1; i >= 0; i--) { + if (list[i] === listener || list[i].listener === listener) { + originalListener = list[i].listener; + position = i; + break; + } + } + + if (position < 0) + return this; + + if (position === 0) + list.shift(); + else { + spliceOne(list, position); + } + + if (list.length === 1) + events[type] = list[0]; + + if (events.removeListener !== undefined) + this.emit('removeListener', type, originalListener || listener); + } + + return this; + }; + +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + +EventEmitter.prototype.removeAllListeners = + function removeAllListeners(type) { + var listeners, events, i; + + events = this._events; + if (events === undefined) + return this; + + // not listening for removeListener, no need to emit + if (events.removeListener === undefined) { + if (arguments.length === 0) { + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else + delete events[type]; + } + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + var keys = Object.keys(events); + var key; + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } + + listeners = events[type]; + + if (typeof listeners === 'function') { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); + } + } + + return this; + }; + +function _listeners(target, type, unwrap) { + var events = target._events; + + if (events === undefined) + return []; + + var evlistener = events[type]; + if (evlistener === undefined) + return []; + + if (typeof evlistener === 'function') + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + + return unwrap ? + unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); +} + +EventEmitter.prototype.listeners = function listeners(type) { + return _listeners(this, type, true); +}; + +EventEmitter.prototype.rawListeners = function rawListeners(type) { + return _listeners(this, type, false); +}; + +EventEmitter.listenerCount = function(emitter, type) { + if (typeof emitter.listenerCount === 'function') { + return emitter.listenerCount(type); + } else { + return listenerCount.call(emitter, type); + } +}; + +EventEmitter.prototype.listenerCount = listenerCount; +function listenerCount(type) { + var events = this._events; + + if (events !== undefined) { + var evlistener = events[type]; + + if (typeof evlistener === 'function') { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; + } + } + + return 0; +} + +EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; +}; + +function arrayClone(arr, n) { + var copy = new Array(n); + for (var i = 0; i < n; ++i) + copy[i] = arr[i]; + return copy; +} + +function spliceOne(list, index) { + for (; index + 1 < list.length; index++) + list[index] = list[index + 1]; + list.pop(); +} + +function unwrapListeners(arr) { + var ret = new Array(arr.length); + for (var i = 0; i < ret.length; ++i) { + ret[i] = arr[i].listener || arr[i]; + } + return ret; +} + +function once(emitter, name) { + return new Promise(function (resolve, reject) { + function errorListener(err) { + emitter.removeListener(name, resolver); + reject(err); + } + + function resolver() { + if (typeof emitter.removeListener === 'function') { + emitter.removeListener('error', errorListener); + } + resolve([].slice.call(arguments)); + }; + + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== 'error') { + addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); + } + }); +} + +function addErrorHandlerIfEventEmitter(emitter, handler, flags) { + if (typeof emitter.on === 'function') { + eventTargetAgnosticAddListener(emitter, 'error', handler, flags); + } +} + +function eventTargetAgnosticAddListener(emitter, name, listener, flags) { + if (typeof emitter.on === 'function') { + if (flags.once) { + emitter.once(name, listener); + } else { + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === 'function') { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we do not listen for `error` events here. + emitter.addEventListener(name, function wrapListener(arg) { + // IE does not have builtin `{ once: true }` support so we + // have to do it manually. + if (flags.once) { + emitter.removeEventListener(name, wrapListener); + } + listener(arg); + }); + } else { + throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); + } +} + + +/***/ }), + +/***/ 196: +/*!*****************************************!*\ + !*** ./node_modules/tslib/tslib.es6.js ***! + \*****************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ __assign: () => (/* binding */ __assign), +/* harmony export */ __asyncDelegator: () => (/* binding */ __asyncDelegator), +/* harmony export */ __asyncGenerator: () => (/* binding */ __asyncGenerator), +/* harmony export */ __asyncValues: () => (/* binding */ __asyncValues), +/* harmony export */ __await: () => (/* binding */ __await), +/* harmony export */ __awaiter: () => (/* binding */ __awaiter), +/* harmony export */ __classPrivateFieldGet: () => (/* binding */ __classPrivateFieldGet), +/* harmony export */ __classPrivateFieldSet: () => (/* binding */ __classPrivateFieldSet), +/* harmony export */ __createBinding: () => (/* binding */ __createBinding), +/* harmony export */ __decorate: () => (/* binding */ __decorate), +/* harmony export */ __exportStar: () => (/* binding */ __exportStar), +/* harmony export */ __extends: () => (/* binding */ __extends), +/* harmony export */ __generator: () => (/* binding */ __generator), +/* harmony export */ __importDefault: () => (/* binding */ __importDefault), +/* harmony export */ __importStar: () => (/* binding */ __importStar), +/* harmony export */ __makeTemplateObject: () => (/* binding */ __makeTemplateObject), +/* harmony export */ __metadata: () => (/* binding */ __metadata), +/* harmony export */ __param: () => (/* binding */ __param), +/* harmony export */ __read: () => (/* binding */ __read), +/* harmony export */ __rest: () => (/* binding */ __rest), +/* harmony export */ __spread: () => (/* binding */ __spread), +/* harmony export */ __spreadArray: () => (/* binding */ __spreadArray), +/* harmony export */ __spreadArrays: () => (/* binding */ __spreadArrays), +/* harmony export */ __values: () => (/* binding */ __values) +/* harmony export */ }); +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + +var extendStatics = function(d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); +}; + +function __extends(d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +} + +var __assign = function() { + __assign = Object.assign || function __assign(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; + } + return __assign.apply(this, arguments); +} + +function __rest(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +} + +function __decorate(decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +} + +function __param(paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +} + +function __metadata(metadataKey, metadataValue) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); +} + +function __awaiter(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()); + }); +} + +function __generator(thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +} + +var __createBinding = Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +}); + +function __exportStar(m, o) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); +} + +function __values(o) { + var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; + if (m) return m.call(o); + if (o && typeof o.length === "number") return { + next: function () { + if (o && i >= o.length) o = void 0; + return { value: o && o[i++], done: !o }; + } + }; + throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); +} + +function __read(o, n) { + var m = typeof Symbol === "function" && o[Symbol.iterator]; + if (!m) return o; + var i = m.call(o), r, ar = [], e; + try { + while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); + } + catch (error) { e = { error: error }; } + finally { + try { + if (r && !r.done && (m = i["return"])) m.call(i); + } + finally { if (e) throw e.error; } + } + return ar; +} + +/** @deprecated */ +function __spread() { + for (var ar = [], i = 0; i < arguments.length; i++) + ar = ar.concat(__read(arguments[i])); + return ar; +} + +/** @deprecated */ +function __spreadArrays() { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +} + +function __spreadArray(to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +} + +function __await(v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); +} + +function __asyncGenerator(thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +} + +function __asyncDelegator(o) { + var i, p; + return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i; + function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; } +} + +function __asyncValues(o) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var m = o[Symbol.asyncIterator], i; + return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i); + function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; } + function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } +} + +function __makeTemplateObject(cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; +}; + +var __setModuleDefault = Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}; + +function __importStar(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +} + +function __importDefault(mod) { + return (mod && mod.__esModule) ? mod : { default: mod }; +} + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +function __classPrivateFieldSet(receiver, state, value, kind, f) { + if (kind === "m") throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value; +} + + +/***/ }), + +/***/ 976: +/*!***************************************************************************!*\ + !*** ./node_modules/webpack-dev-server/client/clients/WebSocketClient.js ***! + \***************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ WebSocketClient) +/* harmony export */ }); +/* harmony import */ var _utils_log_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/log.js */ 43); +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); } +function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } } +function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } + + +/** @typedef {import("../index").EXPECTED_ANY} EXPECTED_ANY */ + +/** + * @implements {CommunicationClient} + */ +var WebSocketClient = /*#__PURE__*/function () { + /** + * @param {string} url url to connect + */ + function WebSocketClient(url) { + _classCallCheck(this, WebSocketClient); + this.client = new WebSocket(url); + this.client.onerror = function (error) { + _utils_log_js__WEBPACK_IMPORTED_MODULE_0__.log.error(error); + }; + } + + /** + * @param {(...args: EXPECTED_ANY[]) => void} fn function + */ + return _createClass(WebSocketClient, [{ + key: "onOpen", + value: function onOpen(fn) { + this.client.onopen = fn; + } + + /** + * @param {(...args: EXPECTED_ANY[]) => void} fn function + */ + }, { + key: "onClose", + value: function onClose(fn) { + this.client.onclose = fn; + } + + // call f with the message string as the first argument + /** + * @param {(...args: EXPECTED_ANY[]) => void} fn function + */ + }, { + key: "onMessage", + value: function onMessage(fn) { + this.client.onmessage = function (err) { + fn(err.data); + }; + } + }]); +}(); + + +/***/ }), + +/***/ 29: +/*!************************************************************************************************************************************************************************************!*\ + !*** ./node_modules/webpack-dev-server/client/index.js?protocol=wss&hostname=localhost&port=4321&pathname=%2Fws&logging=info&overlay=false&reconnect=10&hot=true&live-reload=true ***! + \************************************************************************************************************************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +var __resourceQuery = "?protocol=wss&hostname=localhost&port=4321&pathname=%2Fws&logging=info&overlay=false&reconnect=10&hot=true&live-reload=true"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ createSocketURL: () => (/* binding */ createSocketURL), +/* harmony export */ getCurrentScriptSource: () => (/* binding */ getCurrentScriptSource), +/* harmony export */ parseURL: () => (/* binding */ parseURL) +/* harmony export */ }); +/* harmony import */ var webpack_hot_emitter_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! webpack/hot/emitter.js */ 689); +/* harmony import */ var webpack_hot_emitter_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(webpack_hot_emitter_js__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var webpack_hot_log_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! webpack/hot/log.js */ 509); +/* harmony import */ var webpack_hot_log_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(webpack_hot_log_js__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var _overlay_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./overlay.js */ 887); +/* harmony import */ var _progress_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./progress.js */ 40); +/* harmony import */ var _socket_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./socket.js */ 930); +/* harmony import */ var _utils_log_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./utils/log.js */ 43); +/* harmony import */ var _utils_sendMessage_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./utils/sendMessage.js */ 912); +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +/* global __resourceQuery, __webpack_hash__ */ +// @ts-expect-error + +// @ts-expect-error + + + + + + + +// eslint-disable-next-line jsdoc/no-restricted-syntax +/** @typedef {any} EXPECTED_ANY */ + +/** + * @typedef {object} RawOverlayOptions + * @property {string=} warnings warnings + * @property {string=} errors errors + * @property {string=} runtimeErrors runtime errors + * @property {string=} trustedTypesPolicyName trusted types policy name + */ + +/** + * @typedef {object} OverlayOptions + * @property {(boolean | ((error: Error) => boolean))=} warnings warnings + * @property {(boolean | ((error: Error) => boolean))=} errors errors + * @property {(boolean | ((error: Error) => boolean))=} runtimeErrors runtime errors + * @property {string=} trustedTypesPolicyName trusted types policy name + */ + +/** @typedef {false | true | "none" | "error" | "warn" | "info" | "log" | "verbose"} LogLevel */ + +/** + * @typedef {object} Options + * @property {boolean} hot true when hot enabled, otherwise false + * @property {boolean} liveReload true when live reload enabled, otherwise false + * @property {boolean} progress true when need to show progress, otherwise false + * @property {boolean | OverlayOptions} overlay overlay options + * @property {LogLevel=} logging logging level + * @property {number=} reconnect count of allowed reconnection + */ + +/** + * @typedef {object} Status + * @property {boolean} isUnloading true when unloaded, otherwise false + * @property {string} currentHash current hash + * @property {string=} previousHash previous hash + */ + +/** + * @param {boolean | RawOverlayOptions | OverlayOptions} overlayOptions overlay options + */ +var decodeOverlayOptions = function decodeOverlayOptions(overlayOptions) { + if (_typeof(overlayOptions) === "object") { + var requiredOptions = ["warnings", "errors", "runtimeErrors"]; + for (var i = 0; i < requiredOptions.length; i++) { + var property = /** @type {keyof Omit} */ + requiredOptions[i]; + if (typeof overlayOptions[property] === "string") { + var overlayFilterFunctionString = decodeURIComponent(overlayOptions[property]); + + /** @type {OverlayOptions} */ + overlayOptions[property] = /** @type {(error: Error) => boolean} */ + // eslint-disable-next-line no-new-func + new Function("message", "var callback = ".concat(overlayFilterFunctionString, "\n return callback(message)")); + } + } + } +}; + +/** + * @type {Status} + */ +var status = { + isUnloading: false, + currentHash: __webpack_require__.h() +}; + +/** + * @returns {string} current script source + */ +var getCurrentScriptSource = function getCurrentScriptSource() { + // `document.currentScript` is the most accurate way to find the current script, + // but is not supported in all browsers. + if (document.currentScript) { + return /** @type {string} */document.currentScript.getAttribute("src"); + } + + // Fallback to getting all scripts running in the document. + var scriptElements = document.scripts || []; + var scriptElementsWithSrc = Array.prototype.filter.call(scriptElements, function (element) { + return element.getAttribute("src"); + }); + if (scriptElementsWithSrc.length > 0) { + var currentScript = scriptElementsWithSrc[scriptElementsWithSrc.length - 1]; + return currentScript.getAttribute("src"); + } + + // Fail as there was no script to use. + throw new Error("[webpack-dev-server] Failed to get current script source."); +}; + +/** @typedef {{ hot?: string, ["live-reload"]?: string, progress?: string, reconnect?: string, logging?: LogLevel, overlay?: string, fromCurrentScript?: boolean }} AdditionalParsedURL */ +/** @typedef {Partial & AdditionalParsedURL} ParsedURL */ + +/** + * @param {string} resourceQuery resource query + * @returns {ParsedURL} parsed URL + */ +var parseURL = function parseURL(resourceQuery) { + /** @type {ParsedURL} */ + var result = {}; + if (typeof resourceQuery === "string" && resourceQuery !== "") { + var searchParams = resourceQuery.slice(1).split("&"); + for (var i = 0; i < searchParams.length; i++) { + var pair = searchParams[i].split("="); + + /** @type {EXPECTED_ANY} */ + result[pair[0]] = decodeURIComponent(pair[1]); + } + } else { + // Else, get the url from the