{"version":3,"file":"static/js/5feab019fea3be990fd2.bundle.js","mappings":"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","sources":["webpack://Msdyn365.Commerce.Online/./node_modules/object-inspect/index.js?24d4","webpack://Msdyn365.Commerce.Online/./node_modules/path-browserify/index.js?ce03","webpack://Msdyn365.Commerce.Online/./node_modules/object-assign/index.js?f7fe","webpack://Msdyn365.Commerce.Online/../src/components/Spinner/Spinner.types.ts?d830","webpack://Msdyn365.Commerce.Online/../src/components/Spinner/Spinner.base.tsx?dabc","webpack://Msdyn365.Commerce.Online/../src/components/Spinner/Spinner.styles.tsx?beac","webpack://Msdyn365.Commerce.Online/../src/components/Spinner/Spinner.tsx?3f11"],"sourcesContent":["var hasMap = typeof Map === 'function' && Map.prototype;\nvar mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;\nvar mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;\nvar mapForEach = hasMap && Map.prototype.forEach;\nvar hasSet = typeof Set === 'function' && Set.prototype;\nvar setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;\nvar setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;\nvar setForEach = hasSet && Set.prototype.forEach;\nvar hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;\nvar weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\nvar hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;\nvar weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\nvar hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;\nvar weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\nvar booleanValueOf = Boolean.prototype.valueOf;\nvar objectToString = Object.prototype.toString;\nvar functionToString = Function.prototype.toString;\nvar $match = String.prototype.match;\nvar $slice = String.prototype.slice;\nvar $replace = String.prototype.replace;\nvar $toUpperCase = String.prototype.toUpperCase;\nvar $toLowerCase = String.prototype.toLowerCase;\nvar $test = RegExp.prototype.test;\nvar $concat = Array.prototype.concat;\nvar $join = Array.prototype.join;\nvar $arrSlice = Array.prototype.slice;\nvar $floor = Math.floor;\nvar bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;\nvar gOPS = Object.getOwnPropertySymbols;\nvar symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;\nvar hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';\n// ie, `has-tostringtag/shams\nvar toStringTag = typeof Symbol === 'function' && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? 'object' : 'symbol')\n    ? Symbol.toStringTag\n    : null;\nvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\nvar gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (\n    [].__proto__ === Array.prototype // eslint-disable-line no-proto\n        ? function (O) {\n            return O.__proto__; // eslint-disable-line no-proto\n        }\n        : null\n);\n\nfunction addNumericSeparator(num, str) {\n    if (\n        num === Infinity\n        || num === -Infinity\n        || num !== num\n        || (num && num > -1000 && num < 1000)\n        || $test.call(/e/, str)\n    ) {\n        return str;\n    }\n    var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n    if (typeof num === 'number') {\n        var int = num < 0 ? -$floor(-num) : $floor(num); // trunc(num)\n        if (int !== num) {\n            var intStr = String(int);\n            var dec = $slice.call(str, intStr.length + 1);\n            return $replace.call(intStr, sepRegex, '$&_') + '.' + $replace.call($replace.call(dec, /([0-9]{3})/g, '$&_'), /_$/, '');\n        }\n    }\n    return $replace.call(str, sepRegex, '$&_');\n}\n\nvar utilInspect = require('./util.inspect');\nvar inspectCustom = utilInspect.custom;\nvar inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;\n\nvar quotes = {\n    __proto__: null,\n    'double': '\"',\n    single: \"'\"\n};\nvar quoteREs = {\n    __proto__: null,\n    'double': /([\"\\\\])/g,\n    single: /(['\\\\])/g\n};\n\nmodule.exports = function inspect_(obj, options, depth, seen) {\n    var opts = options || {};\n\n    if (has(opts, 'quoteStyle') && !has(quotes, opts.quoteStyle)) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n    }\n    if (\n        has(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'\n            ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity\n            : opts.maxStringLength !== null\n        )\n    ) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n    }\n    var customInspect = has(opts, 'customInspect') ? opts.customInspect : true;\n    if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {\n        throw new TypeError('option \"customInspect\", if provided, must be `true`, `false`, or `\\'symbol\\'`');\n    }\n\n    if (\n        has(opts, 'indent')\n        && opts.indent !== null\n        && opts.indent !== '\\t'\n        && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)\n    ) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n    }\n    if (has(opts, 'numericSeparator') && typeof opts.numericSeparator !== 'boolean') {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n    }\n    var numericSeparator = opts.numericSeparator;\n\n    if (typeof obj === 'undefined') {\n        return 'undefined';\n    }\n    if (obj === null) {\n        return 'null';\n    }\n    if (typeof obj === 'boolean') {\n        return obj ? 'true' : 'false';\n    }\n\n    if (typeof obj === 'string') {\n        return inspectString(obj, opts);\n    }\n    if (typeof obj === 'number') {\n        if (obj === 0) {\n            return Infinity / obj > 0 ? '0' : '-0';\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n    }\n    if (typeof obj === 'bigint') {\n        var bigIntStr = String(obj) + 'n';\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n    }\n\n    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;\n    if (typeof depth === 'undefined') { depth = 0; }\n    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {\n        return isArray(obj) ? '[Array]' : '[Object]';\n    }\n\n    var indent = getIndent(opts, depth);\n\n    if (typeof seen === 'undefined') {\n        seen = [];\n    } else if (indexOf(seen, obj) >= 0) {\n        return '[Circular]';\n    }\n\n    function inspect(value, from, noIndent) {\n        if (from) {\n            seen = $arrSlice.call(seen);\n            seen.push(from);\n        }\n        if (noIndent) {\n            var newOpts = {\n                depth: opts.depth\n            };\n            if (has(opts, 'quoteStyle')) {\n                newOpts.quoteStyle = opts.quoteStyle;\n            }\n            return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n    }\n\n    if (typeof obj === 'function' && !isRegExp(obj)) { // in older engines, regexes are callable\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect);\n        return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + $join.call(keys, ', ') + ' }' : '');\n    }\n    if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, '$1') : symToString.call(obj);\n        return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;\n    }\n    if (isElement(obj)) {\n        var s = '<' + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);\n        }\n        s += '>';\n        if (obj.childNodes && obj.childNodes.length) { s += '...'; }\n        s += '</' + $toLowerCase.call(String(obj.nodeName)) + '>';\n        return s;\n    }\n    if (isArray(obj)) {\n        if (obj.length === 0) { return '[]'; }\n        var xs = arrObjKeys(obj, inspect);\n        if (indent && !singleLineValues(xs)) {\n            return '[' + indentedJoin(xs, indent) + ']';\n        }\n        return '[ ' + $join.call(xs, ', ') + ' ]';\n    }\n    if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect);\n        if (!('cause' in Error.prototype) && 'cause' in obj && !isEnumerable.call(obj, 'cause')) {\n            return '{ [' + String(obj) + '] ' + $join.call($concat.call('[cause]: ' + inspect(obj.cause), parts), ', ') + ' }';\n        }\n        if (parts.length === 0) { return '[' + String(obj) + ']'; }\n        return '{ [' + String(obj) + '] ' + $join.call(parts, ', ') + ' }';\n    }\n    if (typeof obj === 'object' && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === 'function' && utilInspect) {\n            return utilInspect(obj, { depth: maxDepth - depth });\n        } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {\n            return obj.inspect();\n        }\n    }\n    if (isMap(obj)) {\n        var mapParts = [];\n        if (mapForEach) {\n            mapForEach.call(obj, function (value, key) {\n                mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));\n            });\n        }\n        return collectionOf('Map', mapSize.call(obj), mapParts, indent);\n    }\n    if (isSet(obj)) {\n        var setParts = [];\n        if (setForEach) {\n            setForEach.call(obj, function (value) {\n                setParts.push(inspect(value, obj));\n            });\n        }\n        return collectionOf('Set', setSize.call(obj), setParts, indent);\n    }\n    if (isWeakMap(obj)) {\n        return weakCollectionOf('WeakMap');\n    }\n    if (isWeakSet(obj)) {\n        return weakCollectionOf('WeakSet');\n    }\n    if (isWeakRef(obj)) {\n        return weakCollectionOf('WeakRef');\n    }\n    if (isNumber(obj)) {\n        return markBoxed(inspect(Number(obj)));\n    }\n    if (isBigInt(obj)) {\n        return markBoxed(inspect(bigIntValueOf.call(obj)));\n    }\n    if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n    }\n    if (isString(obj)) {\n        return markBoxed(inspect(String(obj)));\n    }\n    // note: in IE 8, sometimes `global !== window` but both are the prototypes of each other\n    /* eslint-env browser */\n    if (typeof window !== 'undefined' && obj === window) {\n        return '{ [object Window] }';\n    }\n    if (\n        (typeof globalThis !== 'undefined' && obj === globalThis)\n        || (typeof global !== 'undefined' && obj === global)\n    ) {\n        return '{ [object globalThis] }';\n    }\n    if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? '' : 'null prototype';\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? 'Object' : '';\n        var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';\n        var tag = constructorTag + (stringTag || protoTag ? '[' + $join.call($concat.call([], stringTag || [], protoTag || []), ': ') + '] ' : '');\n        if (ys.length === 0) { return tag + '{}'; }\n        if (indent) {\n            return tag + '{' + indentedJoin(ys, indent) + '}';\n        }\n        return tag + '{ ' + $join.call(ys, ', ') + ' }';\n    }\n    return String(obj);\n};\n\nfunction wrapQuotes(s, defaultStyle, opts) {\n    var style = opts.quoteStyle || defaultStyle;\n    var quoteChar = quotes[style];\n    return quoteChar + s + quoteChar;\n}\n\nfunction quote(s) {\n    return $replace.call(String(s), /\"/g, '&quot;');\n}\n\nfunction canTrustToString(obj) {\n    return !toStringTag || !(typeof obj === 'object' && (toStringTag in obj || typeof obj[toStringTag] !== 'undefined'));\n}\nfunction isArray(obj) { return toStr(obj) === '[object Array]' && canTrustToString(obj); }\nfunction isDate(obj) { return toStr(obj) === '[object Date]' && canTrustToString(obj); }\nfunction isRegExp(obj) { return toStr(obj) === '[object RegExp]' && canTrustToString(obj); }\nfunction isError(obj) { return toStr(obj) === '[object Error]' && canTrustToString(obj); }\nfunction isString(obj) { return toStr(obj) === '[object String]' && canTrustToString(obj); }\nfunction isNumber(obj) { return toStr(obj) === '[object Number]' && canTrustToString(obj); }\nfunction isBoolean(obj) { return toStr(obj) === '[object Boolean]' && canTrustToString(obj); }\n\n// Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives\nfunction isSymbol(obj) {\n    if (hasShammedSymbols) {\n        return obj && typeof obj === 'object' && obj instanceof Symbol;\n    }\n    if (typeof obj === 'symbol') {\n        return true;\n    }\n    if (!obj || typeof obj !== 'object' || !symToString) {\n        return false;\n    }\n    try {\n        symToString.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isBigInt(obj) {\n    if (!obj || typeof obj !== 'object' || !bigIntValueOf) {\n        return false;\n    }\n    try {\n        bigIntValueOf.call(obj);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nvar hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };\nfunction has(obj, key) {\n    return hasOwn.call(obj, key);\n}\n\nfunction toStr(obj) {\n    return objectToString.call(obj);\n}\n\nfunction nameOf(f) {\n    if (f.name) { return f.name; }\n    var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n    if (m) { return m[1]; }\n    return null;\n}\n\nfunction indexOf(xs, x) {\n    if (xs.indexOf) { return xs.indexOf(x); }\n    for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) { return i; }\n    }\n    return -1;\n}\n\nfunction isMap(x) {\n    if (!mapSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        mapSize.call(x);\n        try {\n            setSize.call(x);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof Map; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakMap(x) {\n    if (!weakMapHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n            weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakRef(x) {\n    if (!weakRefDeref || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakRefDeref.call(x);\n        return true;\n    } catch (e) {}\n    return false;\n}\n\nfunction isSet(x) {\n    if (!setSize || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        setSize.call(x);\n        try {\n            mapSize.call(x);\n        } catch (m) {\n            return true;\n        }\n        return x instanceof Set; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isWeakSet(x) {\n    if (!weakSetHas || !x || typeof x !== 'object') {\n        return false;\n    }\n    try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n            weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n            return true;\n        }\n        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0\n    } catch (e) {}\n    return false;\n}\n\nfunction isElement(x) {\n    if (!x || typeof x !== 'object') { return false; }\n    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {\n        return true;\n    }\n    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';\n}\n\nfunction inspectString(str, opts) {\n    if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n    }\n    var quoteRE = quoteREs[opts.quoteStyle || 'single'];\n    quoteRE.lastIndex = 0;\n    // eslint-disable-next-line no-control-regex\n    var s = $replace.call($replace.call(str, quoteRE, '\\\\$1'), /[\\x00-\\x1f]/g, lowbyte);\n    return wrapQuotes(s, 'single', opts);\n}\n\nfunction lowbyte(c) {\n    var n = c.charCodeAt(0);\n    var x = {\n        8: 'b',\n        9: 't',\n        10: 'n',\n        12: 'f',\n        13: 'r'\n    }[n];\n    if (x) { return '\\\\' + x; }\n    return '\\\\x' + (n < 0x10 ? '0' : '') + $toUpperCase.call(n.toString(16));\n}\n\nfunction markBoxed(str) {\n    return 'Object(' + str + ')';\n}\n\nfunction weakCollectionOf(type) {\n    return type + ' { ? }';\n}\n\nfunction collectionOf(type, size, entries, indent) {\n    var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ', ');\n    return type + ' (' + size + ') {' + joinedEntries + '}';\n}\n\nfunction singleLineValues(xs) {\n    for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], '\\n') >= 0) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction getIndent(opts, depth) {\n    var baseIndent;\n    if (opts.indent === '\\t') {\n        baseIndent = '\\t';\n    } else if (typeof opts.indent === 'number' && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), ' ');\n    } else {\n        return null;\n    }\n    return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n    };\n}\n\nfunction indentedJoin(xs, indent) {\n    if (xs.length === 0) { return ''; }\n    var lineJoiner = '\\n' + indent.prev + indent.base;\n    return lineJoiner + $join.call(xs, ',' + lineJoiner) + '\\n' + indent.prev;\n}\n\nfunction arrObjKeys(obj, inspect) {\n    var isArr = isArray(obj);\n    var xs = [];\n    if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';\n        }\n    }\n    var syms = typeof gOPS === 'function' ? gOPS(obj) : [];\n    var symMap;\n    if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n            symMap['$' + syms[k]] = syms[k];\n        }\n    }\n\n    for (var key in obj) { // eslint-disable-line no-restricted-syntax\n        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue\n        if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {\n            // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section\n            continue; // eslint-disable-line no-restricted-syntax, no-continue\n        } else if ($test.call(/[^\\w$]/, key)) {\n            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));\n        } else {\n            xs.push(key + ': ' + inspect(obj[key], obj));\n        }\n    }\n    if (typeof gOPS === 'function') {\n        for (var j = 0; j < syms.length; j++) {\n            if (isEnumerable.call(obj, syms[j])) {\n                xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));\n            }\n        }\n    }\n    return xs;\n}\n","// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","import * as React from 'react';\nimport { ITheme, IStyle } from '../../Styling';\nimport { IRefObject, IStyleFunctionOrObject } from '../../Utilities';\n\n/**\n * {@docCategory Spinner}\n */\nexport interface ISpinner {}\n\n/**\n * Spinner component props.\n * {@docCategory Spinner}\n */\nexport interface ISpinnerProps extends React.HTMLAttributes<HTMLElement> {\n  /**\n   * Optional callback to access the ISpinner interface. Use this instead of ref for accessing\n   * the public methods and properties of the component.\n   */\n  componentRef?: IRefObject<ISpinner>;\n\n  /**\n   * Deprecated and will be removed at \\>= 2.0.0. Use `SpinnerSize` instead.\n   * @deprecated Use `SpinnerSize` instead.\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  type?: SpinnerType;\n\n  /**\n   * The size of Spinner to render. \\{ extraSmall, small, medium, large \\}\n   * @defaultvalue SpinnerType.medium\n   */\n  size?: SpinnerSize;\n\n  /**\n   * The label to show next to the Spinner. Label updates will be announced to the screen readers.\n   * Use ariaLive to control politeness level.\n   */\n  label?: string;\n\n  /**\n   * Additional CSS class(es) to apply to the Spinner.\n   */\n  className?: string;\n\n  /**\n   * Politeness setting for label update announcement.\n   * @defaultvalue polite\n   */\n  ariaLive?: 'assertive' | 'polite' | 'off';\n\n  /**\n   * Alternative status label for screen reader\n   */\n  ariaLabel?: string;\n\n  /**\n   * Theme (provided through customization.)\n   */\n  theme?: ITheme;\n\n  /**\n   * Call to provide customized styling that will layer on top of the variant rules.\n   */\n  styles?: IStyleFunctionOrObject<ISpinnerStyleProps, ISpinnerStyles>;\n\n  /**\n   * The position of the label in regards of the spinner animation.\n   * @defaultvalue SpinnerLabelPosition.bottom\n   */\n  labelPosition?: SpinnerLabelPosition;\n}\n\n/**\n * Possible variations of the spinner circle size.\n * {@docCategory Spinner}\n */\nexport enum SpinnerSize {\n  /**\n   * 12px Spinner diameter\n   */\n  xSmall = 0,\n\n  /**\n   * 16px Spinner diameter\n   */\n  small = 1,\n\n  /**\n   * 20px Spinner diameter\n   */\n  medium = 2,\n\n  /**\n   * 28px Spinner diameter\n   */\n  large = 3,\n}\n\n/**\n * Possible locations of the label in regards to the spinner\n * @defaultvalue bottom\n * {@docCategory Spinner}\n */\nexport type SpinnerLabelPosition = 'top' | 'right' | 'bottom' | 'left';\n\n/**\n * Deprecated at v2.0.0, use `SpinnerSize` instead.\n * @deprecated Use `SpinnerSize` instead.\n * {@docCategory Spinner}\n */\nexport enum SpinnerType {\n  /**\n   * Deprecated and will be removed at \\>= 2.0.0. Use `SpinnerSize.medium` instead.\n   * @deprecated Use `SpinnerSize.medium` instead.\n   */\n  normal = 0,\n\n  /**\n   * Deprecated and will be removed at \\>= 2.0.0. Use `SpinnerSize.large` instead.\n   * @deprecated Use `SpinnerSize.large` instead.\n   */\n  large = 1,\n}\n\n/**\n * The props needed to construct styles.\n * This represents the simplified set of immutable things which control the class names.\n * {@docCategory Spinner}\n */\nexport interface ISpinnerStyleProps {\n  /** Theme provided by High-Order Component. */\n  theme: ITheme;\n\n  /** Size of the spinner animation. */\n  size?: SpinnerSize;\n\n  /** CSS class name for the component attached to the root stylable area. */\n  className?: string;\n\n  /** Position of the label in regards to the spinner animation. */\n  labelPosition?: SpinnerLabelPosition;\n}\n\n/**\n * Represents the stylable areas of the control.\n * {@docCategory Spinner}\n */\nexport interface ISpinnerStyles {\n  /** Styles for the root element. Refers to the wrapper containing both the circle and the label. */\n  root?: IStyle;\n\n  /** Styles for the spinner circle animation. */\n  circle?: IStyle;\n\n  /** Styles for the label accompanying the circle. */\n  label?: IStyle;\n\n  /** Styles for the hidden helper element to aid with screen readers. */\n  screenReaderText?: IStyle;\n}\n","import * as React from 'react';\nimport { ISpinnerProps, ISpinnerStyleProps, ISpinnerStyles, SpinnerType, SpinnerSize } from './Spinner.types';\nimport { classNamesFunction, DelayedRender, getNativeProps, divProperties } from '../../Utilities';\n\nconst getClassNames = classNamesFunction<ISpinnerStyleProps, ISpinnerStyles>();\n\nexport class SpinnerBase extends React.Component<ISpinnerProps, any> {\n  public static defaultProps: ISpinnerProps = {\n    size: SpinnerSize.medium,\n    ariaLive: 'polite',\n    labelPosition: 'bottom',\n  };\n\n  public render() {\n    // eslint-disable-next-line deprecation/deprecation\n    const { type, size, ariaLabel, ariaLive, styles, label, theme, className, labelPosition } = this.props;\n    const statusMessage = ariaLabel;\n    const nativeProps = getNativeProps<React.HTMLAttributes<HTMLDivElement>>(this.props, divProperties, ['size']);\n\n    // SpinnerType is deprecated. If someone is still using this property, rather than putting the SpinnerType into the\n    // ISpinnerStyleProps, we'll map SpinnerType to its equivalent SpinnerSize and pass that in. Once SpinnerType\n    // finally goes away we should delete this.\n    let styleSize = size;\n    if (styleSize === undefined && type !== undefined) {\n      // eslint-disable-next-line deprecation/deprecation\n      styleSize = type === SpinnerType.large ? SpinnerSize.large : SpinnerSize.medium;\n    }\n\n    const classNames = getClassNames(styles!, {\n      theme: theme!,\n      size: styleSize,\n      className,\n      labelPosition,\n    });\n\n    return (\n      <div {...nativeProps} className={classNames.root}>\n        <div className={classNames.circle} />\n        {label && <div className={classNames.label}>{label}</div>}\n        {statusMessage && (\n          <div role=\"status\" aria-live={ariaLive}>\n            <DelayedRender>\n              <div className={classNames.screenReaderText}>{statusMessage}</div>\n            </DelayedRender>\n          </div>\n        )}\n      </div>\n    );\n  }\n}\n","import { ISpinnerStyleProps, ISpinnerStyles, SpinnerSize } from './Spinner.types';\nimport {\n  hiddenContentStyle,\n  keyframes,\n  HighContrastSelector,\n  getGlobalClassNames,\n  getEdgeChromiumNoHighContrastAdjustSelector,\n} from '../../Styling';\nimport { memoizeFunction } from '../../Utilities';\n\nconst GlobalClassNames = {\n  root: 'ms-Spinner',\n  circle: 'ms-Spinner-circle',\n  label: 'ms-Spinner-label',\n};\n\nconst spinAnimation = memoizeFunction(() =>\n  keyframes({\n    '0%': {\n      transform: 'rotate(0deg)',\n    },\n    '100%': {\n      transform: 'rotate(360deg)',\n    },\n  }),\n);\n\nexport const getStyles = (props: ISpinnerStyleProps): ISpinnerStyles => {\n  const { theme, size, className, labelPosition } = props;\n\n  const { palette } = theme;\n\n  const classNames = getGlobalClassNames(GlobalClassNames, theme);\n\n  return {\n    root: [\n      classNames.root,\n      {\n        display: 'flex',\n        flexDirection: 'column',\n        alignItems: 'center',\n        justifyContent: 'center',\n      },\n      labelPosition === 'top' && {\n        flexDirection: 'column-reverse',\n      },\n      labelPosition === 'right' && {\n        flexDirection: 'row',\n      },\n      labelPosition === 'left' && {\n        flexDirection: 'row-reverse',\n      },\n      className,\n    ],\n    circle: [\n      classNames.circle,\n      {\n        boxSizing: 'border-box',\n        borderRadius: '50%',\n        border: '1.5px solid ' + palette.themeLight,\n        borderTopColor: palette.themePrimary,\n        animationName: spinAnimation(),\n        animationDuration: '1.3s',\n        animationIterationCount: 'infinite',\n        animationTimingFunction: 'cubic-bezier(.53,.21,.29,.67)',\n        selectors: {\n          [HighContrastSelector]: {\n            borderTopColor: 'Highlight',\n          },\n          ...getEdgeChromiumNoHighContrastAdjustSelector(),\n        },\n      },\n      size === SpinnerSize.xSmall && [\n        'ms-Spinner--xSmall',\n        {\n          width: 12,\n          height: 12,\n        },\n      ],\n      size === SpinnerSize.small && [\n        'ms-Spinner--small',\n        {\n          width: 16,\n          height: 16,\n        },\n      ],\n      size === SpinnerSize.medium && [\n        'ms-Spinner--medium',\n        {\n          width: 20,\n          height: 20,\n        },\n      ],\n      size === SpinnerSize.large && [\n        'ms-Spinner--large',\n        {\n          width: 28,\n          height: 28,\n        },\n      ],\n    ],\n    label: [\n      classNames.label,\n      theme.fonts.small,\n      {\n        color: palette.themePrimary,\n        margin: '8px 0 0',\n        textAlign: 'center',\n      },\n      labelPosition === 'top' && {\n        margin: '0 0 8px',\n      },\n      labelPosition === 'right' && {\n        margin: '0 0 0 8px',\n      },\n      labelPosition === 'left' && {\n        margin: '0 8px 0 0',\n      },\n    ],\n    screenReaderText: hiddenContentStyle,\n  };\n};\n","import * as React from 'react';\nimport { styled } from '../../Utilities';\nimport { SpinnerBase } from './Spinner.base';\nimport { getStyles } from './Spinner.styles';\nimport { ISpinnerProps, ISpinnerStyles, ISpinnerStyleProps } from './Spinner.types';\n\nexport const Spinner: React.FunctionComponent<ISpinnerProps> = styled<\n  ISpinnerProps,\n  ISpinnerStyleProps,\n  ISpinnerStyles\n>(SpinnerBase, getStyles, undefined, { scope: 'Spinner' });\n"],"names":["hasMap","Map","prototype","mapSizeDescriptor","Object","getOwnPropertyDescriptor","mapSize","get","mapForEach","forEach","hasSet","Set","setSizeDescriptor","setSize","setForEach","weakMapHas","WeakMap","has","weakSetHas","WeakSet","weakRefDeref","WeakRef","deref","booleanValueOf","Boolean","valueOf","objectToString","toString","functionToString","Function","$match","String","match","$slice","slice","$replace","replace","$toUpperCase","toUpperCase","$toLowerCase","toLowerCase","$test","RegExp","test","$concat","Array","concat","$join","join","$arrSlice","$floor","Math","floor","bigIntValueOf","BigInt","gOPS","getOwnPropertySymbols","symToString","Symbol","iterator","hasShammedSymbols","toStringTag","isEnumerable","propertyIsEnumerable","gPO","Reflect","getPrototypeOf","__proto__","O","addNumericSeparator","num","str","Infinity","call","sepRegex","int","intStr","dec","length","utilInspect","inspectCustom","custom","inspectSymbol","isSymbol","quotes","single","quoteREs","wrapQuotes","s","defaultStyle","opts","style","quoteStyle","quoteChar","quote","canTrustToString","obj","isArray","toStr","isRegExp","e","module","exports","inspect_","options","depth","seen","TypeError","maxStringLength","customInspect","indent","parseInt","numericSeparator","inspectString","bigIntStr","maxDepth","baseIndent","base","prev","getIndent","indexOf","inspect","value","from","noIndent","push","newOpts","name","f","m","nameOf","keys","arrObjKeys","symString","markBoxed","x","HTMLElement","nodeName","getAttribute","isElement","attrs","attributes","i","childNodes","xs","singleLineValues","indentedJoin","isError","parts","Error","cause","isMap","mapParts","key","collectionOf","isSet","setParts","isWeakMap","weakCollectionOf","isWeakSet","isWeakRef","isNumber","Number","isBigInt","isBoolean","isString","window","globalThis","g","isDate","ys","isPlainObject","constructor","protoTag","stringTag","tag","hasOwn","hasOwnProperty","this","l","remaining","trailer","quoteRE","lastIndex","lowbyte","c","n","charCodeAt","8","9","10","12","13","type","size","entries","lineJoiner","isArr","symMap","syms","k","j","assertPath","path","JSON","stringify","normalizeStringPosix","allowAboveRoot","code","res","lastSegmentLength","lastSlash","dots","lastSlashIndex","lastIndexOf","posix","resolve","cwd","resolvedPath","resolvedAbsolute","arguments","undefined","process","normalize","isAbsolute","trailingSeparator","joined","arg","relative","to","fromStart","fromEnd","fromLen","toStart","toLen","lastCommonSep","fromCode","out","_makeLong","dirname","hasRoot","end","matchedSlash","basename","ext","start","extIdx","firstNonSlashEnd","extname","startDot","startPart","preDotState","format","pathObject","sep","dir","root","_format","parse","ret","delimiter","win32","propIsEnumerable","toObject","val","assign","test1","getOwnPropertyNames","test2","fromCharCode","map","test3","split","letter","err","shouldUseNative","target","source","symbols","SpinnerSize","SpinnerType","getClassNames","classNamesFunction","render","ariaLabel","ariaLive","styles","label","theme","className","labelPosition","statusMessage","nativeProps","props","styleSize","large","medium","classNames","circle","role","DelayedRender","screenReaderText","defaultProps","GlobalClassNames","spinAnimation","memoize","transform","Spinner","styled","SpinnerBase","palette","display","flexDirection","alignItems","justifyContent","boxSizing","borderRadius","border","themeLight","borderTopColor","themePrimary","animationName","animationDuration","animationIterationCount","animationTimingFunction","selectors","xSmall","width","height","small","fonts","color","margin","textAlign","scope"],"sourceRoot":""}