first commit

node_modules/@microsoft/load-themed-styles/LICENSE

@@ -0,0 +1,24 @@
+@microsoft/load-themed-styles
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+MIT License
+
+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/@microsoft/load-themed-styles/README.md

@@ -0,0 +1,66 @@
+# @microsoft/load-themed-styles
+[![npm version](https://badge.fury.io/js/%40microsoft%2Fload-themed-styles.svg)](https://badge.fury.io/js/%40microsoft%2Fload-themed-styles)
+
+> Loads a string of style rules, but supports detokenizing theme constants built within it.
+
+## Install
+
+Install with [npm](https://www.npmjs.com/)
+
+```
+$ npm install --save @microsoft/load-themed-styles
+```
+
+## Usage
+
+To load a given string of styles, you can do this in TypeScript or ES6:
+
+```TypeScript
+import { loadStyles } from '@microsoft/load-themed-styles';
+
+loadStyles('body { background: red; }');
+```
+
+This will register any set of styles given. However, in the above example the color is hardcoded to red. To make this theme-able, replace it with the string token in this format:
+
+```
+"[theme:{variableName}, default:{defaultValue}]"
+```
+
+For example:
+
+```js
+loadStyles('body { background: "[theme:primaryBackgroundColor, default: blue]"');
+```
+
+When loading, the background will use the default value, blue. Providing your own theme values using the `loadTheme` function:
+
+```js
+import { loadStyles, loadTheme } from '@microsoft/load-themed-styles';
+
+loadTheme({
+  primaryBackgroundColor: "#EAEAEA"
+});
+
+loadStyles('body { background: "[theme:primaryBackgroundColor, default: #FFAAFA]"');
+```
+
+This will register #EAEAEA as the body's background color. If you call `loadTheme` again after styles have already been registered, it will replace the style elements with retokenized values.
+
+## Security considerations
+
+In order for `style` elements to be added to the DOM, a `nonce` attribute may need to be attached to the elements to adhere to a CSP requirements. To provide the value, you can specify the `nonce` value by defining a `CSPSettings` object on the page in global scope:
+
+```js
+window.CSPSettings = {
+  nonce: 'nonce'
+};
+```
+
+## Links
+
+- [CHANGELOG.md](
+  https://github.com/microsoft/rushstack/blob/main/libraries/load-themed-styles/CHANGELOG.md) - Find
+  out what's new in the latest version
+
+`@microsoft/load-themed-styles` is part of the [Rush Stack](https://rushstack.io/) family of projects.

node_modules/@microsoft/load-themed-styles/lib-amd/index.js

@@ -0,0 +1,309 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.splitStyles = exports.detokenize = exports.clearStyles = exports.loadTheme = exports.flush = exports.configureRunMode = exports.configureLoadStyles = exports.loadStyles = void 0;
+    // 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' ? global : 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);
+            }
+        });
+    }
+    exports.loadStyles = loadStyles;
+    /**
+     * 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;
+    }
+    exports.configureLoadStyles = configureLoadStyles;
+    /**
+     * Configure run mode of load-themable-styles
+     * @param mode load-themable-styles run mode, async or sync
+     */
+    function configureRunMode(mode) {
+        _themeState.runState.mode = mode;
+    }
+    exports.configureRunMode = configureRunMode;
+    /**
+     * 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);
+            }
+        });
+    }
+    exports.flush = flush;
+    /**
+     * 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();
+    }
+    exports.loadTheme = loadTheme;
+    /**
+     * 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 = [];
+        }
+    }
+    exports.clearStyles = clearStyles;
+    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;
+    }
+    exports.detokenize = detokenize;
+    /**
+     * 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) &&
+                    typeof DEBUG !== 'undefined' &&
+                    DEBUG) {
+                    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;
+    }
+    exports.splitStyles = splitStyles;
+    /**
+     * 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);
+        }
+    }
+});
+//# sourceMappingURL=index.js.map

node_modules/@microsoft/load-themed-styles/lib-es6/index.js

@@ -0,0 +1,296 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+// 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' ? global : 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.
+ */
+export 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
+ */
+export function configureLoadStyles(loadStylesFn) {
+    _themeState.loadStyles = loadStylesFn;
+}
+/**
+ * Configure run mode of load-themable-styles
+ * @param mode load-themable-styles run mode, async or sync
+ */
+export function configureRunMode(mode) {
+    _themeState.runState.mode = mode;
+}
+/**
+ * external code can call flush to synchronously force processing of currently buffered styles
+ */
+export 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.
+ */
+export 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
+ */
+export 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.
+ */
+export 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) &&
+                typeof DEBUG !== 'undefined' &&
+                DEBUG) {
+                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.
+ */
+export 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);
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@microsoft/load-themed-styles/lib/index.d.ts

@@ -0,0 +1,74 @@
+export interface IThemingInstruction {
+    theme?: string;
+    defaultValue?: string;
+    rawString?: string;
+}
+export declare type ThemableArray = IThemingInstruction[];
+export interface ITheme {
+    [key: string]: string;
+}
+/**
+ * In sync mode, styles are registered as style elements synchronously with loadStyles() call.
+ * In async mode, styles are buffered and registered as batch in async timer for performance purpose.
+ */
+export declare const enum Mode {
+    sync = 0,
+    async = 1
+}
+/**
+ * Themable styles and non-themable styles are tracked separately
+ * Specify ClearStyleOptions when calling clearStyles API to specify which group of registered styles should be cleared.
+ */
+export declare const enum ClearStyleOptions {
+    /** only themable styles will be cleared */
+    onlyThemable = 1,
+    /** only non-themable styles will be cleared */
+    onlyNonThemable = 2,
+    /** both themable and non-themable styles will be cleared */
+    all = 3
+}
+/**
+ * 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.
+ */
+export declare function loadStyles(styles: string | ThemableArray, loadAsync?: boolean): void;
+/**
+ * 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
+ */
+export declare function configureLoadStyles(loadStylesFn: ((processedStyles: string, rawStyles?: string | ThemableArray) => void) | undefined): void;
+/**
+ * Configure run mode of load-themable-styles
+ * @param mode load-themable-styles run mode, async or sync
+ */
+export declare function configureRunMode(mode: Mode): void;
+/**
+ * external code can call flush to synchronously force processing of currently buffered styles
+ */
+export declare function flush(): void;
+/**
+ * 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.
+ */
+export declare function loadTheme(theme: ITheme | undefined): void;
+/**
+ * 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
+ */
+export declare function clearStyles(option?: ClearStyleOptions): void;
+/**
+ * Find theme tokens and replaces them with provided theme values.
+ * @param {string} styles Tokenized styles to fix.
+ */
+export declare function detokenize(styles: string | undefined): string | undefined;
+/**
+ * Split tokenized CSS into an array of strings and theme specification objects
+ * @param {string} styles Tokenized styles to split.
+ */
+export declare function splitStyles(styles: string): ThemableArray;
+//# sourceMappingURL=index.d.ts.map

node_modules/@microsoft/load-themed-styles/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,oBAAY,aAAa,GAAG,mBAAmB,EAAE,CAAC;AAElD,MAAM,WAAW,MAAM;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB;AA4DD;;;GAGG;AACH,0BAAkB,IAAI;IACpB,IAAI,IAAA;IACJ,KAAK,IAAA;CACN;AAED;;;GAGG;AACH,0BAAkB,iBAAiB;IACjC,2CAA2C;IAC3C,YAAY,IAAI;IAChB,+CAA+C;IAC/C,eAAe,IAAI;IACnB,4DAA4D;IAC5D,GAAG,IAAI;CACR;AA6DD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,SAAS,GAAE,OAAe,GAAG,IAAI,CAa3F;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,CAAC,CAAC,eAAe,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,KAAK,IAAI,CAAC,GAAG,SAAS,GAChG,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAEjD;AAED;;GAEG;AACH,wBAAgB,KAAK,IAAI,IAAI,CAS5B;AA0BD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,GAAE,iBAAyC,GAAG,IAAI,CASnF;AA2BD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAMzE;AA+CD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CA6BzD"}

node_modules/@microsoft/load-themed-styles/lib/index.js

@@ -0,0 +1,307 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitStyles = exports.detokenize = exports.clearStyles = exports.loadTheme = exports.flush = exports.configureRunMode = exports.configureLoadStyles = exports.loadStyles = void 0;
+// 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' ? global : 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);
+        }
+    });
+}
+exports.loadStyles = loadStyles;
+/**
+ * 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;
+}
+exports.configureLoadStyles = configureLoadStyles;
+/**
+ * Configure run mode of load-themable-styles
+ * @param mode load-themable-styles run mode, async or sync
+ */
+function configureRunMode(mode) {
+    _themeState.runState.mode = mode;
+}
+exports.configureRunMode = configureRunMode;
+/**
+ * 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);
+        }
+    });
+}
+exports.flush = flush;
+/**
+ * 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();
+}
+exports.loadTheme = loadTheme;
+/**
+ * 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 = [];
+    }
+}
+exports.clearStyles = clearStyles;
+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;
+}
+exports.detokenize = detokenize;
+/**
+ * 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) &&
+                typeof DEBUG !== 'undefined' &&
+                DEBUG) {
+                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;
+}
+exports.splitStyles = splitStyles;
+/**
+ * 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);
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@microsoft/load-themed-styles/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@microsoft/load-themed-styles",
+  "version": "1.10.295",
+  "description": "Loads themed styles.",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/microsoft/rushstack.git",
+    "type": "git",
+    "directory": "libraries/load-themed-styles"
+  },
+  "main": "lib/index.js",
+  "module": "lib-es6/index.js",
+  "typings": "lib/index.d.ts",
+  "keywords": [],
+  "devDependencies": {
+    "@rushstack/eslint-config": "3.0.0",
+    "@rushstack/heft": "0.47.8",
+    "@rushstack/heft-web-rig": "0.11.10",
+    "@types/heft-jest": "1.0.1",
+    "@types/webpack-env": "1.13.0"
+  },
+  "scripts": {
+    "build": "heft build --clean",
+    "_phase:build": "heft build --clean"
+  }
+}