From 6b3d83fbcdf0c7cb2ea4f2f5f570a74eea038701 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Thu, 5 Feb 2026 17:44:39 +0900 Subject: [PATCH 01/31] Add JSON-RPC2 stdio & HTTP endpoint support Introduce JSON-RPC 2.0 handling and a minimal stdio framing server. Adds ApiEndpoints/JsonRpc2 and JsonRpc2Dispatcher to parse and dispatch JSON-RPC requests, and StdioServer to handle Content-Length framed stdio messages. Adds McpToolsList.json (tools list resource) and wires JsonRpc2 into ResourceServer. Program.cs: add --stdio-jsonrpc2 mode to run the stdio server, and integrate dispatcher usage (with timeout and TODO placeholders for tools/call). ResourceServer: register JsonRpc2 endpoint, change fallback handling to 404 via ServeResource(), and make several resource helper methods static/public for reuse. Update csproj to include new source files and embed the McpToolsList.json resource. Contains basic implementation and scaffolding; tool-call handling is left as TODO. --- .../ApiEndpoints/JsonRpc2.cs | 96 ++++++++ .../WelsonJS.Launcher/JsonRpc2Dispatcher.cs | 80 +++++++ .../WelsonJS.Launcher/McpToolsList.json | 28 +++ .../WelsonJS.Launcher/Program.cs | 68 +++++- .../WelsonJS.Launcher/ResourceServer.cs | 15 +- .../WelsonJS.Launcher/StdioServer.cs | 209 ++++++++++++++++++ .../WelsonJS.Launcher.csproj | 4 + 7 files changed, 489 insertions(+), 11 deletions(-) create mode 100644 WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs create mode 100644 WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs create mode 100644 WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json create mode 100644 WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs new file mode 100644 index 0000000..5964ee5 --- /dev/null +++ b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs @@ -0,0 +1,96 @@ +using log4net; +using System; +using System.Net; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; + +namespace WelsonJS.Launcher.ApiEndpoints +{ + public class JsonRpc2 : IApiEndpoint + { + private readonly ResourceServer Server; + private readonly HttpClient _httpClient; + private readonly ILog _logger; + private const string Prefix = "jsonrpc2"; + + public JsonRpc2(ResourceServer server, HttpClient httpClient, ILog logger) + { + Server = server; + + _httpClient = httpClient; + _logger = logger; + } + + public bool CanHandle(HttpListenerContext context, string path) + { + if (context == null) + return false; + + if (!string.Equals(context.Request.HttpMethod, "POST", StringComparison.OrdinalIgnoreCase)) + return false; + + if (path.StartsWith(Prefix, StringComparison.OrdinalIgnoreCase) == false) + return false; + + string contentType = context.Request.ContentType?.ToLowerInvariant() ?? string.Empty; + if (!(contentType.StartsWith("application/json") + || contentType.StartsWith("application/json-rpc") + || contentType.StartsWith("application/jsonrpc") + || contentType.StartsWith("text/json"))) + return false; + + if (!context.Request.HasEntityBody) + return false; + + return true; + } + + public async Task HandleAsync(HttpListenerContext context, string path) + { + string body; + try + { + using (var input = context.Request.InputStream) + using (var reader = new System.IO.StreamReader(input, System.Text.Encoding.UTF8)) + { + body = await reader.ReadToEndAsync(); + } + + _logger.Debug($"[JsonRpc2] Request body received ({body.Length} bytes)"); + } + catch (Exception ex) + { + _logger.Error("[JsonRpc2] Failed to read request body", ex); + + context.Response.StatusCode = (int)HttpStatusCode.BadRequest; + context.Response.Close(); + return; + } + + var dispatcher = new JsonRpc2Dispatcher(_logger); + + using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(300))) + { + await dispatcher.HandleAsync( + body, + async (method, ser, ct) => + { + switch (method) + { + case "tools/list": + await Server.ServeResource(context, ResourceServer.GetResource("McpToolsList.json"), "application/json"); + break; + + case "tools/call": + // TODO: implement tool calling + break; + } + + return string.Empty; + }, + cts.Token); + } + } + } +} diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs new file mode 100644 index 0000000..cf29716 --- /dev/null +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs @@ -0,0 +1,80 @@ +using log4net; +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace WelsonJS.Launcher +{ + public sealed class JsonRpc2Request + { + public string Version; + public string Method; + } + + public sealed class JsonRpc2Exception : Exception + { + public JsonRpc2Exception(string message) : base(message) { } + public JsonRpc2Exception(string message, Exception inner) : base(message, inner) { } + } + + public sealed class JsonRpc2Dispatcher + { + private readonly ILog _logger; + + public JsonRpc2Dispatcher(ILog logger) + { + _logger = logger; + } + + public async Task HandleAsync( + string requestBody, + Func> dispatchMethodAsync, + CancellationToken ct) + { + if (string.IsNullOrEmpty(requestBody)) + throw new JsonRpc2Exception("Empty request body"); + + if (dispatchMethodAsync == null) + throw new ArgumentNullException("dispatchMethodAsync"); + + using (var ser = new JsSerializer()) + { + int id = ser.Load(requestBody); + + try + { + string version = ser.ExtractFrom(id, "jsonrpc"); + if (!string.Equals(version, "2.0", StringComparison.Ordinal)) + throw new JsonRpc2Exception("Unsupported jsonrpc version: " + version); + + string method = ser.ExtractFrom(id, "method"); + if (string.IsNullOrEmpty(method)) + throw new JsonRpc2Exception("Missing method"); + + var req = new JsonRpc2Request + { + Version = version, + Method = method + }; + + return await dispatchMethodAsync(req.Method, ser, ct); + } + catch (JsonRpc2Exception) + { + throw; + } + catch (Exception ex) + { + if (_logger != null) + _logger.Error("[JsonRpc2] Parse error", ex); + + throw new JsonRpc2Exception("Parse error", ex); + } + finally + { + ser.Unload(id); + } + } + } + } +} \ No newline at end of file diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json b/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json new file mode 100644 index 0000000..26ca8bc --- /dev/null +++ b/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json @@ -0,0 +1,28 @@ +{ + "id": 1, + "jsonrpc": "2.0", + "result": { + "tools": [ + { + "name": "run_jsrt_script", + "title": "Run JSRT Script", + "description": "Execute a JavaScript script on WelsonJS and WSH JSRT (JScript).\n\nOnly ES3-compatible syntax is allowed. ES5 or newer language syntax is not supported.\nA very limited set of ES5 runtime APIs may be available through host-provided compatibility shims, on a best-effort basis and without guarantees.\nDo not rely on strict mode, modern language features, or full polyfill behavior.\nAssume a minimal ES3 execution environment.", + "inputSchema": { + "type": "object", + "properties": { + "script": { + "type": "string", + "description": "JavaScript source code to execute. The script must be written using ES3-compatible syntax and must be suitable for execution in WSH JSRT / WelsonJS." + }, + "timeoutMs": { + "type": "integer", + "description": "Maximum execution time in milliseconds. If the timeout is exceeded, the script execution may be forcibly terminated by the host.", + "minimum": 0 + } + }, + "required": [ "script" ] + } + } + ] + } +} \ No newline at end of file diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs b/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs index d4f8c57..67f5ae4 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs @@ -11,9 +11,14 @@ using System.Diagnostics; using System.IO; using System.IO.Compression; using System.Linq; +using System.Net.Http; using System.Reflection; +using System.Runtime.Remoting.Contexts; +using System.Text; using System.Threading; +using System.Threading.Tasks; using System.Windows.Forms; +using static System.Windows.Forms.VisualStyles.VisualStyleElement.Tab; namespace WelsonJS.Launcher { @@ -49,7 +54,8 @@ namespace WelsonJS.Launcher string targetFilePath = GetTargetFilePath(args); if (!string.IsNullOrEmpty(targetFilePath)) { - try { + try + { HandleTargetFilePath(targetFilePath); } catch (Exception e) @@ -59,6 +65,13 @@ namespace WelsonJS.Launcher return; } + // if use stdio JSON-RPC 2.0 mode + if (HasArg(args, "--stdio-jsonrpc2")) + { + RunJsonRpc2StdioServer(); + return; + } + // create the mutex _mutex = new Mutex(true, "WelsonJS.Launcher", out bool createdNew); if (!createdNew) @@ -81,6 +94,54 @@ namespace WelsonJS.Launcher _mutex.Dispose(); } + private static bool HasArg(string[] args, string key) + { + if (args == null) + return false; + + for (int i = 0; i < args.Length; i++) + if (string.Equals(args[i], key, StringComparison.OrdinalIgnoreCase)) + return true; + + return false; + } + + private static void RunJsonRpc2StdioServer() + { + var server = new StdioServer(async (payload, ct) => + { + var dispatcher = new JsonRpc2Dispatcher(_logger); + var body = Encoding.UTF8.GetString(payload); + + using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(300))) + { + string result = await dispatcher.HandleAsync( + body, + async (method, ser, _ct) => + { + switch (method) + { + case "tools/list": + return Encoding.UTF8.GetString(ResourceServer.GetResource("McpToolList.json")); + + case "tools/call": + // TODO: implement tool call handling + return string.Empty; + + default: + return string.Empty; + } + }, + cts.Token); + + // Fix: Convert string result to byte[] before returning + return Encoding.UTF8.GetBytes(result); + } + }); + + server.Run(); + } + private static void InitializeAssemblyLoader() { byte[] gzBytes = Properties.Resources.Phantomizer; @@ -182,7 +243,8 @@ namespace WelsonJS.Launcher private static string GetTargetFilePath(string[] args) { - if (args == null || args.Length == 0) return null; + if (args == null || args.Length == 0) + return null; for (int i = 0; i < args.Length; i++) { @@ -498,7 +560,7 @@ namespace WelsonJS.Launcher public static void InitializeResourceServer() { - lock(typeof(Program)) + lock (typeof(Program)) { if (_resourceServer == null) { diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/ResourceServer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/ResourceServer.cs index 2a83aef..b6c780a 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/ResourceServer.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/ResourceServer.cs @@ -4,8 +4,6 @@ // https://github.com/gnh1201/welsonjs // using log4net; -using log4net.Core; -using Microsoft.Isam.Esent.Interop; using System; using System.Collections.Generic; using System.IO; @@ -75,6 +73,7 @@ namespace WelsonJS.Launcher _apis.Add(new ApiEndpoints.TwoFactorAuth(this, _httpClient, _logger)); _apis.Add(new ApiEndpoints.Whois(this, _httpClient, _logger)); _apis.Add(new ApiEndpoints.ImageColorPicker(this, _httpClient, _logger)); + _apis.Add(new ApiEndpoints.JsonRpc2(this, _httpClient, _logger)); // Register the prefix _listener.Prefixes.Add(prefix); @@ -164,8 +163,8 @@ namespace WelsonJS.Launcher // Serve from the blob server if (await ServeBlob(context, path)) return; - // Fallback to serve from a resource name - await ServeResource(context, GetResource(_resourceName), "text/html"); + // Fallback to 404 (Not Found) + await ServeResource(context); } private async Task ServeBlob(HttpListenerContext context, string path, string prefix = null) @@ -398,7 +397,7 @@ namespace WelsonJS.Launcher await ServeResource(context, Encoding.UTF8.GetBytes(data), mimeType, statusCode); } - private byte[] GetResource(string resourceName) + public static byte[] GetResource(string resourceName) { // Try to fetch embedded resource. byte[] data = GetEmbeddedResource(typeof(Program).Namespace + "." + resourceName); @@ -408,7 +407,7 @@ namespace WelsonJS.Launcher return GetResourceFromManager(resourceName); } - private byte[] GetEmbeddedResource(string fullResourceName) + private static byte[] GetEmbeddedResource(string fullResourceName) { Assembly assembly = Assembly.GetExecutingAssembly(); using (Stream stream = assembly.GetManifestResourceStream(fullResourceName)) @@ -425,7 +424,7 @@ namespace WelsonJS.Launcher return null; } - private byte[] GetResourceFromManager(string resourceName) + private static byte[] GetResourceFromManager(string resourceName) { object resourceObject = Properties.Resources.ResourceManager.GetObject(resourceName); switch (resourceObject) @@ -439,7 +438,7 @@ namespace WelsonJS.Launcher } } - private byte[] ConvertIconToBytes(System.Drawing.Icon icon) + private static byte[] ConvertIconToBytes(System.Drawing.Icon icon) { using (MemoryStream memoryStream = new MemoryStream()) { diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs new file mode 100644 index 0000000..ac7524c --- /dev/null +++ b/WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs @@ -0,0 +1,209 @@ +// StdioServer.cs +// Minimal stdio server (Content-Length framing) with delegate-based extension. +// - Handles ONLY stdio framing (read/write message boundaries) +// - No JSON parsing/formatting +// - Sequential processing +// - Cancellation via Ctrl+C, and EOF handling +// +// Delegate contract: +// - input: raw UTF-8 payload bytes (exactly Content-Length) +// - output: raw UTF-8 payload bytes to write (or null/empty to write nothing) +// +// Typical use: plug JSON-RPC/MCP dispatcher outside of this class. +using System; +using System.Globalization; +using System.IO; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace WelsonJS.Launcher +{ + public sealed class StdioServer + { + public delegate Task Handler(byte[] payload, CancellationToken ct); + + private readonly Stream _inStream; + private readonly Stream _outStream; + private readonly Handler _handler; + + public StdioServer(Handler handler) + { + if (handler == null) + throw new ArgumentNullException("handler"); + + _handler = handler; + _inStream = Console.OpenStandardInput(); + _outStream = Console.OpenStandardOutput(); + } + + public void Run() + { + using (var cts = new CancellationTokenSource()) + { + Console.CancelKeyPress += (s, e) => + { + e.Cancel = true; + cts.Cancel(); + }; + + RunAsync(cts.Token).GetAwaiter().GetResult(); + } + } + + public async Task RunAsync(CancellationToken ct) + { + while (!ct.IsCancellationRequested) + { + byte[] payload; + + // 1) read one framed message (blocks here waiting for stdin) + try + { + payload = await ReadOneAsync(ct).ConfigureAwait(false); + if (payload == null) return; // EOF => exit + } + catch (OperationCanceledException) + { + return; + } + catch + { + // framing broken or stream error => stop (or continue if you want resync) + return; + } + + // 2) handle + write response (never kill the loop on handler failure) + try + { + var resp = await _handler(payload, ct).ConfigureAwait(false); + if (resp == null) resp = new byte[0]; + + await WriteOneAsync(resp, ct).ConfigureAwait(false); + } + catch (OperationCanceledException) + { + return; + } + catch + { + // keep listening even if handler fails + // optionally write empty response so client doesn't hang waiting + try { await WriteOneAsync(new byte[0], ct).ConfigureAwait(false); } catch { } + continue; + } + } + } + + private async Task ReadOneAsync(CancellationToken ct) + { + // Read headers until \r\n\r\n (blocks on stdin) + string headers = await ReadHeadersAsync(ct).ConfigureAwait(false); + if (headers == null) return null; // EOF + + int contentLength = ParseContentLength(headers); + if (contentLength < 0) throw new InvalidDataException("Missing Content-Length"); + + return await ReadExactAsync(_inStream, contentLength, ct).ConfigureAwait(false); + } + + private async Task WriteOneAsync(byte[] payload, CancellationToken ct) + { + if (payload == null) payload = new byte[0]; + + string header = "Content-Length: " + payload.Length.ToString(CultureInfo.InvariantCulture) + "\r\n\r\n"; + byte[] headerBytes = Encoding.ASCII.GetBytes(header); + + await _outStream.WriteAsync(headerBytes, 0, headerBytes.Length, ct).ConfigureAwait(false); + if (payload.Length > 0) + await _outStream.WriteAsync(payload, 0, payload.Length, ct).ConfigureAwait(false); + + await _outStream.FlushAsync(ct).ConfigureAwait(false); + } + + private async Task ReadHeadersAsync(CancellationToken ct) + { + // read byte-by-byte until CRLFCRLF + var buf = new byte[4096]; + int len = 0; + + while (true) + { + ct.ThrowIfCancellationRequested(); + + int b = await ReadByteAsync(_inStream, ct).ConfigureAwait(false); + if (b < 0) + { + if (len == 0) return null; // clean EOF + throw new EndOfStreamException("EOF while reading headers"); + } + + if (len == buf.Length) + { + // grow + var nb = new byte[buf.Length * 2]; + Buffer.BlockCopy(buf, 0, nb, 0, buf.Length); + buf = nb; + } + + buf[len++] = (byte)b; + + if (len >= 4 && + buf[len - 4] == 13 && + buf[len - 3] == 10 && + buf[len - 2] == 13 && + buf[len - 1] == 10) + { + return Encoding.ASCII.GetString(buf, 0, len); + } + } + } + + private static int ParseContentLength(string headers) + { + // minimal parser: Content-Length: N + var lines = headers.Split(new[] { "\r\n" }, StringSplitOptions.None); + for (int i = 0; i < lines.Length; i++) + { + var line = lines[i]; + int colon = line.IndexOf(':'); + if (colon <= 0) continue; + + var name = line.Substring(0, colon).Trim(); + if (!name.Equals("Content-Length", StringComparison.OrdinalIgnoreCase)) continue; + + var val = line.Substring(colon + 1).Trim(); + int n; + if (int.TryParse(val, NumberStyles.Integer, CultureInfo.InvariantCulture, out n)) + return n; + } + return -1; + } + + private static async Task ReadExactAsync(Stream s, int nBytes, CancellationToken ct) + { + if (nBytes == 0) return new byte[0]; + + var buf = new byte[nBytes]; + int read = 0; + + while (read < nBytes) + { + ct.ThrowIfCancellationRequested(); + int n = await s.ReadAsync(buf, read, nBytes - read, ct).ConfigureAwait(false); + if (n <= 0) throw new EndOfStreamException("EOF while reading payload"); + read += n; + } + + return buf; + } + + private static async Task ReadByteAsync(Stream s, CancellationToken ct) + { + var b = new byte[1]; + int n = await s.ReadAsync(b, 0, 1, ct).ConfigureAwait(false); + if (n <= 0) return -1; + return b[0]; + } + } +} diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj b/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj index 17227f7..24970c3 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj +++ b/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj @@ -91,9 +91,11 @@ + + @@ -131,6 +133,7 @@ GlobalSettingsForm.cs + EnvForm.cs @@ -153,6 +156,7 @@ PreserveNewest + SettingsSingleFileGenerator From 362367f4739db0574a44395955e5ba71791a5317 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Thu, 5 Feb 2026 17:47:56 +0900 Subject: [PATCH 02/31] Remove unused usings from Program.cs Clean up Program.cs by removing unused using directives (System.Net.Http, System.Runtime.Remoting.Contexts, System.Threading.Tasks and the static VisualStyleElement.Tab import). This reduces clutter and compiler warnings and keeps imports focused on required namespaces. --- WelsonJS.Augmented/WelsonJS.Launcher/Program.cs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs b/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs index 67f5ae4..711dd49 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs @@ -11,14 +11,10 @@ using System.Diagnostics; using System.IO; using System.IO.Compression; using System.Linq; -using System.Net.Http; using System.Reflection; -using System.Runtime.Remoting.Contexts; using System.Text; using System.Threading; -using System.Threading.Tasks; using System.Windows.Forms; -using static System.Windows.Forms.VisualStyles.VisualStyleElement.Tab; namespace WelsonJS.Launcher { From c16603af42a2c2fa20ea8bd9bf40282abfb6a5b1 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Fri, 6 Feb 2026 14:31:57 +0900 Subject: [PATCH 03/31] Rename global store to __WJS__ and adjust serialization Rename the global store identifier from __WJ_STORE to __WJS__ throughout JsSerializer.cs (store access in load/unload/set/get and EnsureStore initialization). Also change value retrieval to only JSON.stringify objects and use String(v) for primitives to avoid wrapping non-objects in JSON. Preserve the Object.create(null) store initialization to prevent prototype pollution. --- .../WelsonJS.Launcher/JsSerializer.cs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsSerializer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsSerializer.cs index 8261edc..c037786 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/JsSerializer.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsSerializer.cs @@ -44,7 +44,7 @@ namespace WelsonJS.Launcher // Create slot and parse // Using Object.create(null) for a clean dictionary without prototype. var sb = new StringBuilder(); - sb.Append("(function(){var S=globalThis.__WJ_STORE;"); + sb.Append("(function(){var S=globalThis.__WJS__;"); sb.Append("S[").Append(id.ToString(CultureInfo.InvariantCulture)).Append("]=JSON.parse(").Append(Q(json)).Append(");"); sb.Append("return '1';})()"); string r = _core.EvaluateToString(sb.ToString()); @@ -59,7 +59,7 @@ namespace WelsonJS.Launcher public void Unload(int id) { EnsureStore(); - string script = "(function(){var S=globalThis.__WJ_STORE; delete S[" + id.ToString(CultureInfo.InvariantCulture) + "]; return '1';})()"; + string script = "(function(){var S=globalThis.__WJS__; delete S[" + id.ToString(CultureInfo.InvariantCulture) + "]; return '1';})()"; _core.EvaluateToString(script); } @@ -70,7 +70,7 @@ namespace WelsonJS.Launcher { if (json == null) throw new ArgumentNullException("json"); EnsureStore(); - string script = "(function(){var S=globalThis.__WJ_STORE; S[" + id.ToString(CultureInfo.InvariantCulture) + "]=JSON.parse(" + Q(json) + "); return '1';})()"; + string script = "(function(){var S=globalThis.__WJS__; S[" + id.ToString(CultureInfo.InvariantCulture) + "]=JSON.parse(" + Q(json) + "); return '1';})()"; _core.EvaluateToString(script); } @@ -81,7 +81,7 @@ namespace WelsonJS.Launcher { EnsureStore(); space = Clamp(space, 0, 10); - string script = "(function(){var v=globalThis.__WJ_STORE[" + id.ToString(CultureInfo.InvariantCulture) + "]; return JSON.stringify(v,null," + space.ToString(CultureInfo.InvariantCulture) + ");})()"; + string script = "(function(){var v=globalThis.__WJS__[" + id.ToString(CultureInfo.InvariantCulture) + "]; return JSON.stringify(v,null," + space.ToString(CultureInfo.InvariantCulture) + ");})()"; return _core.EvaluateToString(script); } @@ -96,13 +96,13 @@ namespace WelsonJS.Launcher string jsPath = BuildJsPath(path); var sb = new StringBuilder(); - sb.Append("(function(){var v=globalThis.__WJ_STORE[") + sb.Append("(function(){var v=globalThis.__WJS__[") .Append(id.ToString(CultureInfo.InvariantCulture)) .Append("];var p=").Append(jsPath).Append(";"); sb.Append("for(var i=0;i Date: Fri, 6 Feb 2026 14:32:45 +0900 Subject: [PATCH 04/31] Add SPDX license header to JsonRpc2Dispatcher Insert file header comments in JsonRpc2Dispatcher.cs to declare licensing and attribution: SPDX-License-Identifier: GPL-3.0-or-later, copyright notice for Catswords OSS and WelsonJS Contributors, and project URL. This clarifies file license and provenance. --- WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs index cf29716..5df4c4a 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs @@ -1,4 +1,9 @@ -using log4net; +// JsonRpc2Dispatcher.cs +// SPDX-License-Identifier: GPL-3.0-or-later +// SPDX-FileCopyrightText: 2025 Catswords OSS and WelsonJS Contributors +// https://github.com/gnh1201/welsonjs +// +using log4net; using System; using System.Threading; using System.Threading.Tasks; From 91e18bbb0eadc8ef7de36a642ad044683449fb24 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Fri, 6 Feb 2026 15:10:04 +0900 Subject: [PATCH 05/31] Use HTTP forwarder for stdio-jsonrpc2 Replace the old StdioServer-based stdio JSON-RPC flow with an in-process HTTP forwarder. Program.cs now reads raw stdin, posts payloads to the configured ResourceServerPrefix + "jsonrpc2" using HttpClient (configurable timeout), writes HTTP response bytes back to stdout, and includes improved logging and SafePreviewUtf8 for safe payload previews. StdioServer.cs and its project entry were removed, and Resources.resx HttpClientTimeout was increased to 300 (Designer version updated). This centralizes stdio handling and HTTP forwarding with better error handling and diagnostics. --- .../WelsonJS.Launcher/Program.cs | 135 ++++++++--- .../Properties/Resources.Designer.cs | 4 +- .../Properties/Resources.resx | 2 +- .../WelsonJS.Launcher/StdioServer.cs | 209 ------------------ .../WelsonJS.Launcher.csproj | 1 - 5 files changed, 113 insertions(+), 238 deletions(-) delete mode 100644 WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs b/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs index 711dd49..83c6630 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Program.cs @@ -11,9 +11,12 @@ using System.Diagnostics; using System.IO; using System.IO.Compression; using System.Linq; +using System.Net.Http; +using System.Net.Http.Headers; using System.Reflection; using System.Text; using System.Threading; +using System.Threading.Tasks; using System.Windows.Forms; namespace WelsonJS.Launcher @@ -61,10 +64,11 @@ namespace WelsonJS.Launcher return; } - // if use stdio JSON-RPC 2.0 mode + // if use the stdio-jsonrpc2 forwarder if (HasArg(args, "--stdio-jsonrpc2")) { - RunJsonRpc2StdioServer(); + _logger.Info("Starting in the stdio-jsonrpc2 forwarder..."); + ProcessStdioJsonRpc2().GetAwaiter().GetResult(); return; } @@ -102,40 +106,121 @@ namespace WelsonJS.Launcher return false; } - private static void RunJsonRpc2StdioServer() + private async static Task ProcessStdioJsonRpc2() { - var server = new StdioServer(async (payload, ct) => + string serverPrefix = GetAppConfig("ResourceServerPrefix"); + string endpoint = $"{serverPrefix}jsonrpc2"; + int timeout = int.TryParse(GetAppConfig("HttpClientTimeout"), out timeout) ? timeout : 300; + + var http = new HttpClient { - var dispatcher = new JsonRpc2Dispatcher(_logger); - var body = Encoding.UTF8.GetString(payload); + Timeout = TimeSpan.FromSeconds(timeout) + }; - using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(300))) + using (var stdin = Console.OpenStandardInput()) + using (var stdout = Console.OpenStandardOutput()) + { + var buffer = new byte[8192]; + + while (true) { - string result = await dispatcher.HandleAsync( - body, - async (method, ser, _ct) => + int read; + try + { + read = await stdin.ReadAsync(buffer, 0, buffer.Length); + } + catch (Exception ex) + { + _logger.Error("[stdio] stdin read failed", ex); + break; + } + + if (read <= 0) + { + _logger.Info("[stdio] EOF received, exiting loop"); + break; + } + + byte[] payload = new byte[read]; + Buffer.BlockCopy(buffer, 0, payload, 0, read); + + _logger.Debug($"[stdio] recv {payload.Length} bytes"); + _logger.Debug($"[stdio] payload preview: {SafePreviewUtf8(payload, 512)}"); + + try + { + using (var content = new ByteArrayContent(payload)) { - switch (method) + // Content-Type: application/json + content.Headers.ContentType = + new MediaTypeHeaderValue("application/json") + { + CharSet = "utf-8" + }; + + _logger.Debug($"[http] POST {endpoint}"); + + using (var response = await http.PostAsync(endpoint, content)) { - case "tools/list": - return Encoding.UTF8.GetString(ResourceServer.GetResource("McpToolList.json")); + _logger.Info( + $"[http] status={(int)response.StatusCode} {response.ReasonPhrase}"); - case "tools/call": - // TODO: implement tool call handling - return string.Empty; + foreach (var h in response.Headers) + _logger.Debug($"[http] H {h.Key}: {string.Join(", ", h.Value)}"); - default: - return string.Empty; + foreach (var h in response.Content.Headers) + _logger.Debug($"[http] HC {h.Key}: {string.Join(", ", h.Value)}"); + + byte[] responseBytes = + await response.Content.ReadAsByteArrayAsync(); + + _logger.Debug($"[http] body {responseBytes.Length} bytes"); + + _logger.Debug( + $"[http] body preview: {SafePreviewUtf8(responseBytes, 2048)}"); + + await stdout.WriteAsync(responseBytes, 0, responseBytes.Length); + await stdout.FlushAsync(); } - }, - cts.Token); - - // Fix: Convert string result to byte[] before returning - return Encoding.UTF8.GetBytes(result); + } + } + catch (TaskCanceledException ex) + { + _logger.Error("[http] request timed out or canceled", ex); + } + catch (HttpRequestException ex) + { + _logger.Error("[http] request failed", ex); + } + catch (Exception ex) + { + _logger.Error("[http] unexpected error", ex); + } } - }); + } + } - server.Run(); + private static string SafePreviewUtf8(byte[] bytes, int maxBytes) + { + if (bytes == null || bytes.Length == 0) + return "(empty)"; + + try + { + int len = Math.Min(bytes.Length, maxBytes); + string s = Encoding.UTF8.GetString(bytes, 0, len); + + s = s.Replace("\r", "\\r").Replace("\n", "\\n"); + + if (bytes.Length > maxBytes) + s += $"...(truncated, total {bytes.Length} bytes)"; + + return s; + } + catch + { + return "(binary / non-utf8 response)"; + } } private static void InitializeAssemblyLoader() diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs index 4edcfc2..ddc28cb 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs @@ -19,7 +19,7 @@ namespace WelsonJS.Launcher.Properties { // 클래스에서 자동으로 생성되었습니다. // 멤버를 추가하거나 제거하려면 .ResX 파일을 편집한 다음 /str 옵션을 사용하여 ResGen을 // 다시 실행하거나 VS 프로젝트를 다시 빌드하십시오. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] internal class Resources { @@ -197,7 +197,7 @@ namespace WelsonJS.Launcher.Properties { } /// - /// 90과(와) 유사한 지역화된 문자열을 찾습니다. + /// 300과(와) 유사한 지역화된 문자열을 찾습니다. /// internal static string HttpClientTimeout { get { diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx index bb52cbb..d51141b 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx @@ -188,7 +188,7 @@ https://catswords.blob.core.windows.net/welsonjs/blob.config.xml - 90 + 300 diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs deleted file mode 100644 index ac7524c..0000000 --- a/WelsonJS.Augmented/WelsonJS.Launcher/StdioServer.cs +++ /dev/null @@ -1,209 +0,0 @@ -// StdioServer.cs -// Minimal stdio server (Content-Length framing) with delegate-based extension. -// - Handles ONLY stdio framing (read/write message boundaries) -// - No JSON parsing/formatting -// - Sequential processing -// - Cancellation via Ctrl+C, and EOF handling -// -// Delegate contract: -// - input: raw UTF-8 payload bytes (exactly Content-Length) -// - output: raw UTF-8 payload bytes to write (or null/empty to write nothing) -// -// Typical use: plug JSON-RPC/MCP dispatcher outside of this class. -using System; -using System.Globalization; -using System.IO; -using System.Text; -using System.Threading; -using System.Threading.Tasks; - -namespace WelsonJS.Launcher -{ - public sealed class StdioServer - { - public delegate Task Handler(byte[] payload, CancellationToken ct); - - private readonly Stream _inStream; - private readonly Stream _outStream; - private readonly Handler _handler; - - public StdioServer(Handler handler) - { - if (handler == null) - throw new ArgumentNullException("handler"); - - _handler = handler; - _inStream = Console.OpenStandardInput(); - _outStream = Console.OpenStandardOutput(); - } - - public void Run() - { - using (var cts = new CancellationTokenSource()) - { - Console.CancelKeyPress += (s, e) => - { - e.Cancel = true; - cts.Cancel(); - }; - - RunAsync(cts.Token).GetAwaiter().GetResult(); - } - } - - public async Task RunAsync(CancellationToken ct) - { - while (!ct.IsCancellationRequested) - { - byte[] payload; - - // 1) read one framed message (blocks here waiting for stdin) - try - { - payload = await ReadOneAsync(ct).ConfigureAwait(false); - if (payload == null) return; // EOF => exit - } - catch (OperationCanceledException) - { - return; - } - catch - { - // framing broken or stream error => stop (or continue if you want resync) - return; - } - - // 2) handle + write response (never kill the loop on handler failure) - try - { - var resp = await _handler(payload, ct).ConfigureAwait(false); - if (resp == null) resp = new byte[0]; - - await WriteOneAsync(resp, ct).ConfigureAwait(false); - } - catch (OperationCanceledException) - { - return; - } - catch - { - // keep listening even if handler fails - // optionally write empty response so client doesn't hang waiting - try { await WriteOneAsync(new byte[0], ct).ConfigureAwait(false); } catch { } - continue; - } - } - } - - private async Task ReadOneAsync(CancellationToken ct) - { - // Read headers until \r\n\r\n (blocks on stdin) - string headers = await ReadHeadersAsync(ct).ConfigureAwait(false); - if (headers == null) return null; // EOF - - int contentLength = ParseContentLength(headers); - if (contentLength < 0) throw new InvalidDataException("Missing Content-Length"); - - return await ReadExactAsync(_inStream, contentLength, ct).ConfigureAwait(false); - } - - private async Task WriteOneAsync(byte[] payload, CancellationToken ct) - { - if (payload == null) payload = new byte[0]; - - string header = "Content-Length: " + payload.Length.ToString(CultureInfo.InvariantCulture) + "\r\n\r\n"; - byte[] headerBytes = Encoding.ASCII.GetBytes(header); - - await _outStream.WriteAsync(headerBytes, 0, headerBytes.Length, ct).ConfigureAwait(false); - if (payload.Length > 0) - await _outStream.WriteAsync(payload, 0, payload.Length, ct).ConfigureAwait(false); - - await _outStream.FlushAsync(ct).ConfigureAwait(false); - } - - private async Task ReadHeadersAsync(CancellationToken ct) - { - // read byte-by-byte until CRLFCRLF - var buf = new byte[4096]; - int len = 0; - - while (true) - { - ct.ThrowIfCancellationRequested(); - - int b = await ReadByteAsync(_inStream, ct).ConfigureAwait(false); - if (b < 0) - { - if (len == 0) return null; // clean EOF - throw new EndOfStreamException("EOF while reading headers"); - } - - if (len == buf.Length) - { - // grow - var nb = new byte[buf.Length * 2]; - Buffer.BlockCopy(buf, 0, nb, 0, buf.Length); - buf = nb; - } - - buf[len++] = (byte)b; - - if (len >= 4 && - buf[len - 4] == 13 && - buf[len - 3] == 10 && - buf[len - 2] == 13 && - buf[len - 1] == 10) - { - return Encoding.ASCII.GetString(buf, 0, len); - } - } - } - - private static int ParseContentLength(string headers) - { - // minimal parser: Content-Length: N - var lines = headers.Split(new[] { "\r\n" }, StringSplitOptions.None); - for (int i = 0; i < lines.Length; i++) - { - var line = lines[i]; - int colon = line.IndexOf(':'); - if (colon <= 0) continue; - - var name = line.Substring(0, colon).Trim(); - if (!name.Equals("Content-Length", StringComparison.OrdinalIgnoreCase)) continue; - - var val = line.Substring(colon + 1).Trim(); - int n; - if (int.TryParse(val, NumberStyles.Integer, CultureInfo.InvariantCulture, out n)) - return n; - } - return -1; - } - - private static async Task ReadExactAsync(Stream s, int nBytes, CancellationToken ct) - { - if (nBytes == 0) return new byte[0]; - - var buf = new byte[nBytes]; - int read = 0; - - while (read < nBytes) - { - ct.ThrowIfCancellationRequested(); - int n = await s.ReadAsync(buf, read, nBytes - read, ct).ConfigureAwait(false); - if (n <= 0) throw new EndOfStreamException("EOF while reading payload"); - read += n; - } - - return buf; - } - - private static async Task ReadByteAsync(Stream s, CancellationToken ct) - { - var b = new byte[1]; - int n = await s.ReadAsync(b, 0, 1, ct).ConfigureAwait(false); - if (n <= 0) return -1; - return b[0]; - } - } -} diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj b/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj index 24970c3..493029e 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj +++ b/WelsonJS.Augmented/WelsonJS.Launcher/WelsonJS.Launcher.csproj @@ -133,7 +133,6 @@ GlobalSettingsForm.cs - EnvForm.cs From ef6ff90e39fc0f66dcce905b8ec75b4f0a865484 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 9 Feb 2026 13:02:53 +0900 Subject: [PATCH 06/31] Add Leaflet map view and map toggle Integrate a Leaflet-based MapView into the editor UI: load Leaflet CSS/JS resources, add a MapView React component (initializes map, OpenStreetMap tiles, cleanup on unmount, and calls invalidateSize when shown), and wire a new Map button into the ribbon to toggle map visibility. Add show/hide handling for the Editor component (toggle display via a visible prop) and manage map/editor layout by rendering them side-by-side and toggling display. Rename Azure AI references to Azure Cognitive (handler and button id/label) and update related prop names. Minor resource list and styling updates for layout and dependencies. --- .../WelsonJS.Launcher/editor.html | 104 +++++++++++++++--- 1 file changed, 91 insertions(+), 13 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html index 9a72022..f04f2c6 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html +++ b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html @@ -28,6 +28,10 @@ #editor { flex: 3; } + + #mapView { + flex: 3; + } #promptEditor { flex: 1; @@ -60,6 +64,7 @@ } }; + @@ -103,7 +108,8 @@ loadResource("http://localhost:3000/ajax/libs/metroui/dev/lib/metro.css", "text/css", "sha384-4XgOiXH2ZMaWt5s5B35yKi7EAOabhZvx7wO8Jr71q2vZ+uONdRza/6CsK2kpyocd"), loadResource("http://localhost:3000/ajax/libs/metroui/dev/lib/icons.css", "text/css", "sha384-FuLND994etg+RtnpPSPMyNBvL+fEz+xGhbN61WUWuDEeZ+wJzcQ8SGqAMuI5hWrt"), loadResource("http://localhost:3000/ajax/libs/monaco-editor/0.52.2/min/vs/editor/editor.main.css", "text/css", "sha384-06yHXpYRlHEPaR4AS0fB/W+lMN09Zh5e1XMtfkNQdHV38OlhfkOEW5M+pCj3QskC"), - loadResource("http://localhost:3000/ajax/libs/jsoneditor/10.1.3/jsoneditor.min.css", "text/css", "sha384-cj1rYBc4/dVYAknZMTkVCDRL6Knzugf32igVqsuFW0iRWFHKH8Ci8+ekC8gNsFZ+") + loadResource("http://localhost:3000/ajax/libs/jsoneditor/10.1.3/jsoneditor.min.css", "text/css", "sha384-cj1rYBc4/dVYAknZMTkVCDRL6Knzugf32igVqsuFW0iRWFHKH8Ci8+ekC8gNsFZ+"), + loadResource("http://localhost:3000/ajax/libs/leaflet/1.9.4/leaflet.min.css", "text/css", "sha384-c6Rcwz4e4CITMbu/NBmnNS8yN2sC3cUElMEMfP3vqqKFp7GOYaaBBCqmaWBjmkjb") ]).then(() => { const _e = React.createElement; @@ -128,9 +134,9 @@ } function RibbonMenu({ - onOpenFileClick, onSaveFileClick, onCopliotClick, onAzureAiClick, + onOpenFileClick, onSaveFileClick, onCopliotClick, onAzureCognitiveClick, onSavePromptClick, onLoadPromptClick, onQueryWhoisClick, onQueryDnsClick, - onQueryIpClick + onQueryIpClick, onMapClick }) { const fileButtons = [ { @@ -147,9 +153,9 @@ } ]; - const aiButtons = [ + const cognitiveToolsButtons = [ { id: 'btnCopilot', icon: 'mif-rocket', caption: 'Copilot', onClick: onCopliotClick }, - { id: 'btnAzureAi', icon: 'mif-rocket', caption: 'Azure AI', onClick: onAzureAiClick }, + { id: 'btnAzureCognitive', icon: 'mif-rocket', caption: 'Azure', onClick: onAzureCognitiveClick }, { id: 'btnSavePrompt', icon: 'mif-floppy-disks', caption: 'Save', onClick: onSavePromptClick }, { id: 'btnLoadPrompt', icon: 'mif-file-upload', caption: 'Load', onClick: onLoadPromptClick } ]; @@ -157,7 +163,8 @@ const networkToolsButtons = [ { id: 'btnWhois', icon: 'mif-earth', caption: 'Whois', onClick: onQueryWhoisClick }, { id: 'btnQueryDns', icon: 'mif-earth', caption: 'DNS', onClick: onQueryDnsClick }, - { id: 'btnQueryIp', icon: 'mif-user-secret', caption: 'IP', onClick: onQueryIpClick } + { id: 'btnQueryIp', icon: 'mif-user-secret', caption: 'IP', onClick: onQueryIpClick }, + { id: 'btnMap', icon: 'mif-rocket', caption: 'Map', onClick: onMapClick } ]; return _e( @@ -170,14 +177,14 @@ _e('div', { className: 'content-holder' }, _e('div', { className: 'section active', id: 'editor-tab' }, _e(Group, { title: 'File', buttons: fileButtons }), - _e(Group, { title: 'Generative AI', buttons: aiButtons }), - _e(Group, { title: 'Network tools', buttons: networkToolsButtons }) + _e(Group, { title: 'Cognitive Tools (AI)', buttons: cognitiveToolsButtons }), + _e(Group, { title: 'Network Tools', buttons: networkToolsButtons }) ) ) ); } - function Editor({ editorRef }) { + function Editor({ editorRef, visible }) { const containerRef = React.useRef(null); const getSuggestions = (word, range) => axios.get(`/completion/${encodeURIComponent(word)}`) @@ -232,6 +239,11 @@ editorRef.current = instance; }); }, []); + + React.useEffect(() => { + // toggle the display style attribute + containerRef.current.style.display = (visible ? "" : "none"); + }, [visible]); return _e('div', { id: 'editor', ref: containerRef }); } @@ -281,6 +293,64 @@ return _e('div', { id: 'promptEditor', ref: containerRef }); } + + function MapView({ mapViewRef, visible }) { + const containerRef = React.useRef(null); + + // init once + React.useEffect(() => { + if (!containerRef.current) + return; + + if (typeof L === "undefined" || !L || !L.map) { + console.error("[MapView] Leaflet (L) is not loaded."); + return; + } + + if (mapViewRef && mapViewRef.current && mapViewRef.current._leaflet_id) + return; + + const map = L.map(containerRef.current, { + zoomControl: true, + attributionControl: true + }).setView([37.5665, 126.9780], 12); + + L.tileLayer("https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", { + maxZoom: 19, + attribution: '© OpenStreetMap contributors' + }).addTo(map); + + if (mapViewRef) + mapViewRef.current = map; + + return function () { + try { + if (mapViewRef && mapViewRef.current === map) + mapViewRef.current = null; + + map.remove(); + } catch (e) {} + }; + }, []); + + // handle show/hide toggles + React.useEffect(() => { + // when becoming visible, leaflet needs a resize recalculation + const map = mapViewRef ? mapViewRef.current : null; + if (!map || !map.invalidateSize) + return; + + // toggle the display style attribute + containerRef.current.style.display = (visible ? "block" : "none"); + + // defer until after layout/display change + setTimeout(function () { + try { map.invalidateSize(); } catch (e) {} + }, 0); + }, [visible]); + + return _e('div', { id: 'mapView', ref: containerRef }); + } function App() { const editorRef = React.useRef(null); @@ -288,6 +358,8 @@ const settingsRef = React.useRef({}); const fileNameRef = React.useRef('sayhello.js'); const promptMessagesRef = React.useRef([]); + const mapViewRef = React.useRef(null); + const [showMap, setShowMap] = React.useState(false); const fetchSettings = () => axios.get(`/settings`) .then(response => { @@ -472,7 +544,7 @@ } }; - const sendMessageToAzureAi = () => { + const sendMessageToAzureCognitive = () => { const promptMessage = prompt("Enter a prompt message:", ''); if (!promptMessage || promptMessage.trim() == '') { alert("A prompt message is required."); @@ -647,6 +719,10 @@ appendTextToEditor(`\n// Failed to query the IP: ${error.message}`); }); }; + + function toggleMap() { + setShowMap(v => !v); + } React.useEffect(() => { window.addEventListener('resize', () => { @@ -662,15 +738,17 @@ onOpenFileClick: openFile, onSaveFileClick: saveFile, onCopliotClick: sendMessageToCopilot, - onAzureAiClick: sendMessageToAzureAi, + onAzureCognitiveClick: sendMessageToAzureCognitive, onSavePromptClick: savePromptMessages, onLoadPromptClick: loadPromptMessages, onQueryWhoisClick: queryWhois, onQueryDnsClick: queryDns, - onQueryIpClick: queryIp + onQueryIpClick: queryIp, + onMapClick: toggleMap }), _e('div', { id: 'container' }, - _e(Editor, { editorRef }), + _e(Editor, { editorRef: editorRef, visible: !showMap }), + _e(MapView, { mapViewRef: mapViewRef, visible: showMap }), _e(PromptEditor, { promptEditorRef, promptMessagesRef }) ), _e('div', { className: 'banner' }, _e('a', { href: 'https://github.com/gnh1201/welsonjs' }, '❤️ Contribute this project')), From ec85cc88e4526250aeb7e20da733eef411eabcc6 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 9 Feb 2026 14:49:11 +0900 Subject: [PATCH 07/31] Rename AzureAiService keys to AzureCognitive Rename AzureAiService resource keys and app settings to AzureCognitive across the launcher. Updated Properties/Resources.Designer.cs to use AzureCognitive* properties, changed Resources.resx keys and the service prefix value, and updated app.config appSettings keys accordingly. Also adjusted editor.html to use the new setting names and user-facing "Azure Cognitive" wording and updated how the chat completions URL is constructed to use the AzureCognitive* settings. --- .../Properties/Resources.Designer.cs | 14 +++++++------- .../WelsonJS.Launcher/Properties/Resources.resx | 8 ++++---- WelsonJS.Augmented/WelsonJS.Launcher/app.config | 6 +++--- WelsonJS.Augmented/WelsonJS.Launcher/editor.html | 8 ++++---- 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs index ddc28cb..066c9d5 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs @@ -81,27 +81,27 @@ namespace WelsonJS.Launcher.Properties { /// /// 과(와) 유사한 지역화된 문자열을 찾습니다. /// - internal static string AzureAiServiceApiKey { + internal static string AzureCognitiveApiKey { get { - return ResourceManager.GetString("AzureAiServiceApiKey", resourceCulture); + return ResourceManager.GetString("AzureCognitiveApiKey", resourceCulture); } } /// /// 2024-05-01-preview과(와) 유사한 지역화된 문자열을 찾습니다. /// - internal static string AzureAiServiceApiVersion { + internal static string AzureCognitiveApiVersion { get { - return ResourceManager.GetString("AzureAiServiceApiVersion", resourceCulture); + return ResourceManager.GetString("AzureCognitiveApiVersion", resourceCulture); } } /// - /// https://ai-catswords656881030318.services.ai.azure.com/과(와) 유사한 지역화된 문자열을 찾습니다. + /// https://catswords-ai-resource.services.ai.azure.com/과(와) 유사한 지역화된 문자열을 찾습니다. /// - internal static string AzureAiServicePrefix { + internal static string AzureCognitivePrefix { get { - return ResourceManager.GetString("AzureAiServicePrefix", resourceCulture); + return ResourceManager.GetString("AzureCognitivePrefix", resourceCulture); } } diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx index d51141b..8e229c2 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx @@ -160,11 +160,11 @@ http://localhost:9222/ - + - - https://ai-catswords656881030318.services.ai.azure.com/ + + https://catswords-ai-resource.services.ai.azure.com/ 1.1.1.1 @@ -181,7 +181,7 @@ https://catswords.blob.core.windows.net/welsonjs/ - + 2024-05-01-preview diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/app.config b/WelsonJS.Augmented/WelsonJS.Launcher/app.config index b858537..6001738 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/app.config +++ b/WelsonJS.Augmented/WelsonJS.Launcher/app.config @@ -10,9 +10,9 @@ - - - + + + diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html index f04f2c6..23d7811 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html +++ b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html @@ -551,16 +551,16 @@ return; } - appendTextToEditor(`\n// ${promptMessage}... Generating text with Azure AI...`); + appendTextToEditor(`\n// ${promptMessage}... Generating text with Azure Cognitive...`); pushPromptMessage("user", promptMessage); - const apiKey = settingsRef.current.AzureAiServiceApiKey; + const apiKey = settingsRef.current.AzureCognitiveApiKey; if (!apiKey || apiKey.trim() == '') { - alert("Azure AI API key is not set."); + alert("Azure Cognitive API key is not set."); return; } - const url = `${settingsRef.current.AzureAiServicePrefix}models/chat/completions?api-version=${settingsRef.current.AzureAiServiceApiVersion}`; + const url = `${settingsRef.current.AzureCognitivePrefix}models/chat/completions?api-version=${settingsRef.current.AzureCognitiveApiVersion}`; const data = { messages: promptMessagesRef.current, From 387e86e5a1bc0322e62299435af04917cfbb7a5e Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 9 Feb 2026 22:59:43 +0900 Subject: [PATCH 08/31] Update WHOIS URLs and client IP in app.config Modify WelsonJS.Augmented/WelsonJS.Launcher/app.config to replace the previous punycode WHOIS endpoints with the canonical whois.kr URLs (WhoisServerUrl and WhoisReferrerUrl) and change WhoisClientAddress from 141.101.82.1 to 49.8.14.101. No other configuration values were modified. --- WelsonJS.Augmented/WelsonJS.Launcher/app.config | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/app.config b/WelsonJS.Augmented/WelsonJS.Launcher/app.config index 6001738..80f9244 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/app.config +++ b/WelsonJS.Augmented/WelsonJS.Launcher/app.config @@ -13,9 +13,9 @@ - - - + + + From 2804a4a4df5373e3a8800d9f8f02804c1667b3b3 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 9 Feb 2026 23:24:25 +0900 Subject: [PATCH 09/31] Add location marker to MapView Introduce useLocationMarker hook to manage a Leaflet marker (create, update and bind a popup). MapView now uses the hook and, when visible, requests navigator.geolocation to place/center a marker at the user's current position with a popup showing coordinates. Also includes a small indentation/whitespace cleanup. --- .../WelsonJS.Launcher/editor.html | 35 +++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html index 23d7811..d71aae2 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html +++ b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html @@ -164,7 +164,7 @@ { id: 'btnWhois', icon: 'mif-earth', caption: 'Whois', onClick: onQueryWhoisClick }, { id: 'btnQueryDns', icon: 'mif-earth', caption: 'DNS', onClick: onQueryDnsClick }, { id: 'btnQueryIp', icon: 'mif-user-secret', caption: 'IP', onClick: onQueryIpClick }, - { id: 'btnMap', icon: 'mif-rocket', caption: 'Map', onClick: onMapClick } + { id: 'btnMap', icon: 'mif-rocket', caption: 'Map', onClick: onMapClick } ]; return _e( @@ -294,8 +294,31 @@ return _e('div', { id: 'promptEditor', ref: containerRef }); } + function useLocationMarker(mapViewRef) { + const markerRef = React.useRef(null); + + const mark = React.useCallback((lat, lng, description) => { + const map = mapViewRef.current; + if (!map) return; + + const latlng = L.latLng(lat, lng); + + if (!markerRef.current) { + markerRef.current = L.marker(latlng).addTo(map) + .bindPopup(description || "(no description)") + .openPopup(); + } else { + markerRef.current.setLatLng(latlng); + } + }, [mapViewRef]); + + return { mark, markerRef }; + } + function MapView({ mapViewRef, visible }) { const containerRef = React.useRef(null); + + const { mark } = useLocationMarker(mapViewRef); // init once React.useEffect(() => { @@ -345,7 +368,15 @@ // defer until after layout/display change setTimeout(function () { - try { map.invalidateSize(); } catch (e) {} + try { + map.invalidateSize(); + + if (visible) { + navigator.geolocation.getCurrentPosition(pos => { + mark(pos.coords.latitude, pos.coords.longitude, `My Location: (${pos.coords.latitude}, ${pos.coords.longitude})`); + }); + } + } catch (e) {} }, 0); }, [visible]); From 92f434ec074cb29e91c2460bdb7d3ebe36af72ed Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 9 Feb 2026 23:28:34 +0900 Subject: [PATCH 10/31] Invalidate map and geolocate only when visible Move the setTimeout and its contents inside the visible check so map.invalidateSize() and navigator.geolocation.getCurrentPosition(...) are only invoked when the map container is shown. This avoids unnecessary map invalidation and geolocation requests when the view is hidden; try/catch and the 0ms defer are preserved. --- WelsonJS.Augmented/WelsonJS.Launcher/editor.html | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html index d71aae2..dd8c33b 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/editor.html +++ b/WelsonJS.Augmented/WelsonJS.Launcher/editor.html @@ -367,17 +367,17 @@ containerRef.current.style.display = (visible ? "block" : "none"); // defer until after layout/display change - setTimeout(function () { - try { - map.invalidateSize(); - - if (visible) { + if (visible) { + setTimeout(function () { + try { + map.invalidateSize(); + navigator.geolocation.getCurrentPosition(pos => { mark(pos.coords.latitude, pos.coords.longitude, `My Location: (${pos.coords.latitude}, ${pos.coords.longitude})`); }); - } - } catch (e) {} - }, 0); + } catch (e) {} + }, 0); + } }, [visible]); return _e('div', { id: 'mapView', ref: containerRef }); From 3e5d1208248eb107688a61927a86dabf03cc832d Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Tue, 10 Feb 2026 09:47:02 +0900 Subject: [PATCH 11/31] Update whois resource strings and comments Replace hardcoded WHOIS resource values: change WhoisClientAddress from 141.101.82.1 to 49.8.14.101, and replace punycode domains with the human-readable whois.kr for WhoisReferrerUrl and WhoisServerUrl. Updated Resources.resx and synchronized the generated XML documentation comments in Resources.Designer.cs to reflect the new values. --- .../WelsonJS.Launcher/Properties/Resources.Designer.cs | 6 +++--- .../WelsonJS.Launcher/Properties/Resources.resx | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs index 066c9d5..7252004 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.Designer.cs @@ -407,7 +407,7 @@ namespace WelsonJS.Launcher.Properties { } /// - /// 141.101.82.1과(와) 유사한 지역화된 문자열을 찾습니다. + /// 49.8.14.101과(와) 유사한 지역화된 문자열을 찾습니다. /// internal static string WhoisClientAddress { get { @@ -416,7 +416,7 @@ namespace WelsonJS.Launcher.Properties { } /// - /// https://xn--c79as89aj0e29b77z.xn--3e0b707e/kor/whois/whois.jsp과(와) 유사한 지역화된 문자열을 찾습니다. + /// https://whois.kr/kor/whois/whois.jsp과(와) 유사한 지역화된 문자열을 찾습니다. /// internal static string WhoisReferrerUrl { get { @@ -425,7 +425,7 @@ namespace WelsonJS.Launcher.Properties { } /// - /// https://xn--c79as89aj0e29b77z.xn--3e0b707e/kor/whois.jsc과(와) 유사한 지역화된 문자열을 찾습니다. + /// https://whois.kr/kor/whois.jsc과(와) 유사한 지역화된 문자열을 찾습니다. /// internal static string WhoisServerUrl { get { diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx index 8e229c2..b5f737d 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx +++ b/WelsonJS.Augmented/WelsonJS.Launcher/Properties/Resources.resx @@ -170,13 +170,13 @@ 1.1.1.1 - 141.101.82.1 + 49.8.14.101 - https://xn--c79as89aj0e29b77z.xn--3e0b707e/kor/whois/whois.jsp + https://whois.kr/kor/whois/whois.jsp - https://xn--c79as89aj0e29b77z.xn--3e0b707e/kor/whois.jsc + https://whois.kr/kor/whois.jsc https://catswords.blob.core.windows.net/welsonjs/ From 6101054f2bfb96801f7d31e5275270ac71ef752c Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Tue, 10 Feb 2026 10:10:45 +0900 Subject: [PATCH 12/31] Limit run_jsrt_script timeoutMs to 90 minutes --- .../WelsonJS.Launcher/McpToolsList.json | 690 +++++++++++++++++- 1 file changed, 683 insertions(+), 7 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json b/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json index 26ca8bc..6718e2c 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json +++ b/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json @@ -2,27 +2,703 @@ "id": 1, "jsonrpc": "2.0", "result": { + "runtime": { + "platform": "Windows WSH JsRT (Microsoft JavaScript Runtime)", + "language": "ES3 base + core-js ES5 polyfills", + "moduleSystem": "CommonJS-like require() available in WelsonJS" + }, + "scriptContract": { + "requiredEntryPoint": "function main(args) { /* ... */ }; exports.main = main;", + "notes": [ + "모든 실행 스크립트 결과물은 main 함수를 export해야 합니다.", + "ES3 문법을 기본으로 작성하고, 필요한 경우 ES5 polyfill 범위 내에서만 확장하세요." + ] + }, "tools": [ { "name": "run_jsrt_script", - "title": "Run JSRT Script", - "description": "Execute a JavaScript script on WelsonJS and WSH JSRT (JScript).\n\nOnly ES3-compatible syntax is allowed. ES5 or newer language syntax is not supported.\nA very limited set of ES5 runtime APIs may be available through host-provided compatibility shims, on a best-effort basis and without guarantees.\nDo not rely on strict mode, modern language features, or full polyfill behavior.\nAssume a minimal ES3 execution environment.", + "title": "Run WelsonJS JSRT Script", + "description": "Execute JavaScript on WelsonJS/WSH JsRT. Use ES3-compatible syntax with WelsonJS-provided ES5 polyfills. require() can load modules under lib/. The script must export main: function main(args) { ... }; exports.main = main;", "inputSchema": { "type": "object", "properties": { "script": { "type": "string", - "description": "JavaScript source code to execute. The script must be written using ES3-compatible syntax and must be suitable for execution in WSH JSRT / WelsonJS." + "description": "WelsonJS script source code. Must export main(args)." + }, + "args": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Arguments passed to main(args)." }, "timeoutMs": { "type": "integer", - "description": "Maximum execution time in milliseconds. If the timeout is exceeded, the script execution may be forcibly terminated by the host.", - "minimum": 0 + "minimum": 0, + "description": "Maximum execution time in milliseconds (up to 90 minutes / 5,400,000 ms).", + "maximum": 5400000 } }, - "required": [ "script" ] + "required": [ + "script" + ] } } + ], + "libraryModules": [ + { + "module": "lib/adb.js", + "functions": [ + "create", + "createEmulator" + ] + }, + { + "module": "lib/anthropic.js", + "functions": [ + "chat" + ] + }, + { + "module": "lib/archive.js", + "functions": [ + "create" + ] + }, + { + "module": "lib/autohotkey.js", + "functions": [ + "execScript" + ] + }, + { + "module": "lib/autoit.js", + "functions": [ + "create" + ] + }, + { + "module": "lib/aviation.js", + "functions": [ + "getData", + "getFlights", + "getRoutes", + "getAirports", + "getAirlines", + "getAircraftTypes", + "getCities", + "getCountries", + "getFlightSchedules", + "getFlightsFuture", + "getRoundTrip", + "getOneWay" + ] + }, + { + "module": "lib/base64.js", + "functions": [ + "encode", + "decode" + ] + }, + { + "module": "lib/browser.js", + "functions": [ + "getIEVersion", + "waitUntil", + "addScript", + "addStylesheet", + "setContent", + "start", + "reload", + "close" + ] + }, + { + "module": "lib/catproxy.js", + "functions": [ + "create", + "CatProxyClient" + ] + }, + { + "module": "lib/chatgpt.js", + "functions": [ + "chat" + ] + }, + { + "module": "lib/chrome.js", + "functions": [ + "create", + "start", + "startWithDebugging", + "startWithDebuggingUA", + "startDebug", + "startDebugInPrivate", + "publisherName" + ] + }, + { + "module": "lib/cloudflare.js", + "functions": [ + "binPath", + "installService" + ] + }, + { + "module": "lib/config.js", + "functions": [ + "getValue" + ] + }, + { + "module": "lib/coupang.js", + "functions": [ + "search" + ] + }, + { + "module": "lib/credentials.js", + "functions": [ + "readFromFile", + "push", + "get" + ] + }, + { + "module": "lib/db.js", + "functions": [ + "open", + "blob2Text", + "saveBlob", + "quoteString" + ] + }, + { + "module": "lib/extramath.js", + "functions": [ + "DTM", + "arrayCos", + "measureSimilarity", + "export_measureSimilarity", + "cartesianProduct", + "clusteredCellsDensity", + "estimateTileStartPosition" + ] + }, + { + "module": "lib/fakeworker.js", + "functions": [ + "create", + "repeat" + ] + }, + { + "module": "lib/file.js", + "functions": [ + "fileExists", + "folderExists", + "fileGet", + "readFile", + "writeFile", + "writeBinaryFile", + "moveFile", + "createFolder", + "deleteFolder", + "deleteFile", + "includeFile", + "getFiles", + "appendFile", + "rotateFile", + "loadEnvFromFile", + "loadEnvFromArgs", + "normalizePath", + "isAbsolutePath", + "getFilesFromFolder", + "CdoCharset" + ] + }, + { + "module": "lib/filetypes.js", + "functions": [ + "getExtensionsByOpenWith" + ] + }, + { + "module": "lib/fsm.js", + "functions": [ + "State", + "FSM" + ] + }, + { + "module": "lib/grok.js", + "functions": [ + "chat" + ] + }, + { + "module": "lib/groq.js", + "functions": [ + "chat" + ] + }, + { + "module": "lib/gtk.js", + "functions": [ + "Widget", + "Window", + "Table", + "Button", + "Entry", + "RadioBox", + "RadioGroup", + "TextBox", + "GladeXML", + "init", + "wait", + "exit" + ] + }, + { + "module": "lib/har.js", + "functions": [ + "HARObject" + ] + }, + { + "module": "lib/hosts.js", + "functions": [ + "getHosts" + ] + }, + { + "module": "lib/http.js", + "functions": [ + "create", + "get", + "post", + "patch", + "put", + "_delete", + "parseURL", + "DEFAULT_USER_AGENT", + "defaultUserAgent" + ] + }, + { + "module": "lib/ip-reputation.js", + "functions": [ + "check" + ] + }, + { + "module": "lib/jsonrpc2.js", + "functions": [ + "wrap", + "create", + "DEFAULT_JSONRPC2_URL" + ] + }, + { + "module": "lib/jsunit.js", + "functions": [ + "JsUnit" + ] + }, + { + "module": "lib/kakaotalk.js", + "functions": [ + "KakaoTalk" + ] + }, + { + "module": "lib/language-inference-engine.js", + "functions": [ + "setBiasMessage", + "LanguageInferenceEngine", + "create" + ] + }, + { + "module": "lib/ldplayer.js", + "functions": [ + "getList" + ] + }, + { + "module": "lib/lz77.js", + "functions": [ + "compress", + "decompress" + ] + }, + { + "module": "lib/msmq.js", + "functions": [ + "MSMQObject", + "open" + ] + }, + { + "module": "lib/msoffice.js", + "functions": [ + "Excel", + "PowerPoint", + "Word", + "Outlook" + ] + }, + { + "module": "lib/nmap.js", + "functions": [ + "PortScanner" + ] + }, + { + "module": "lib/noxplayer.js", + "functions": [ + "getList" + ] + }, + { + "module": "lib/ovftool.js", + "functions": [ + "setCredential", + "create" + ] + }, + { + "module": "lib/pipe-ipc.js", + "functions": [ + "create", + "connect", + "Converter", + "UUIDv4", + "CRC32", + "ForReading", + "ForWriting", + "ForAppending", + "CdoCharset", + "CdoUTF_8", + "CdoUS_ASCII", + "CdoEUC_KR", + "CdoEUC_JP", + "adTypeBinary", + "adTypeText", + "adSaveCreateNotExist", + "adSaveCreateOverWrite", + "adModeReadWrite" + ] + }, + { + "module": "lib/powershell.js", + "functions": [ + "execScript", + "execCommand", + "runAs" + ] + }, + { + "module": "lib/punycode.js", + "functions": [ + "encode", + "decode" + ] + }, + { + "module": "lib/python3.js", + "functions": [ + "PythonObject", + "create", + "execScript" + ] + }, + { + "module": "lib/rand.js", + "functions": [ + "randomize", + "getInt", + "getSeed", + "one", + "makeString", + "uuidv4", + "shuffle", + "rotate", + "sample", + "discardOne", + "discardCallback" + ] + }, + { + "module": "lib/registry.js", + "functions": [ + "getProvider", + "write", + "read", + "destroy", + "create", + "execFile", + "HKCR", + "HKCU", + "HKLM", + "STRING", + "BINARY", + "DWORD", + "QWORD" + ] + }, + { + "module": "lib/router.js", + "functions": [ + "Router" + ] + }, + { + "module": "lib/sandboxie.js", + "functions": [ + "start" + ] + }, + { + "module": "lib/security.js", + "functions": [ + "DISABLED", + "ENABLED", + "setDisableAntiSpyware", + "getDisableAntiSpyware", + "setDisableRegistryTools", + "setDisableTaskMgr", + "getAntiVirusProducts", + "OpenThreatSettings" + ] + }, + { + "module": "lib/sendmail.js", + "functions": [ + "sendmail" + ] + }, + { + "module": "lib/serp.js", + "functions": [ + "parseUrl" + ] + }, + { + "module": "lib/shadowsocks.js", + "functions": [ + "connect" + ] + }, + { + "module": "lib/shell.js", + "functions": [ + "create", + "build", + "exec", + "run", + "show", + "runAs", + "showAs", + "createProcess", + "createDesktopIcon", + "getPathOfMyDocuments", + "CdoCharset" + ] + }, + { + "module": "lib/std.js", + "functions": [ + "Event", + "EventTarget", + "Accessor", + "Storage", + "EventableObject", + "alert", + "confirm", + "prompt" + ] + }, + { + "module": "lib/strings.js", + "functions": [ + "numberFormat", + "splitLines", + "selectLines" + ] + }, + { + "module": "lib/system.js", + "functions": [ + "createProcess", + "getEnvString", + "getAppDataDir", + "get32BitFolder", + "isElevated", + "getOS", + "getDCName", + "getArch", + "getUUID", + "getCurrentWorkingDirectory", + "getDirName", + "getFileName", + "getCurrentScriptDirectory", + "getCurrentScriptName", + "getNetworkInterfaces", + "getProcessList", + "getPIDList", + "isAlivePID", + "getProcessListByName", + "killProcess", + "createShortcut", + "ping", + "getProcessVersion" + ] + }, + { + "module": "lib/task-scheduler.js", + "functions": [ + "connect", + "getRootFolder", + "createAndRegisterTask", + "test" + ] + }, + { + "module": "lib/task.js", + "functions": [ + "__taskQueue__", + "setTimeout", + "setInterval", + "Task", + "TaskQueue", + "createTaskQueue", + "createTask", + "putTask", + "nextTask", + "run", + "stop" + ] + }, + { + "module": "lib/toolkit.js", + "functions": [ + "create", + "getInterface", + "sendClick", + "sendKeys", + "sendFnKey", + "alert", + "confirm", + "prompt", + "NamedSharedMemory", + "openProcess", + "closeProcess", + "encryptString", + "decryptString", + "encryptStringHIGHT", + "decryptStringHIGHT" + ] + }, + { + "module": "lib/totp.js", + "functions": [ + "getPubKey", + "getOtp" + ] + }, + { + "module": "lib/tun2socks.js", + "functions": [ + "binPath", + "assign" + ] + }, + { + "module": "lib/uri.js", + "functions": [ + "parseQueryString" + ] + }, + { + "module": "lib/vbscript.js", + "functions": [ + "execScript", + "execCommand" + ] + }, + { + "module": "lib/virtualinput.js", + "functions": [ + "create", + "moveMouse" + ] + }, + { + "module": "lib/wamr.js", + "functions": [ + "create" + ] + }, + { + "module": "lib/websocket.js", + "functions": [ + "create" + ] + }, + { + "module": "lib/winlibs.js", + "functions": [ + "createManifest", + "loadLibrary", + "SHELL32", + "showControlPanel", + "showNetworkAdapters", + "showEULA" + ] + }, + { + "module": "lib/winservice.js", + "functions": [ + "queryService", + "createService", + "startService", + "stopService", + "deleteService" + ] + }, + { + "module": "lib/wintap.js", + "functions": [ + "infPath", + "binPath", + "before", + "install", + "update", + "query", + "remove" + ] + }, + { + "module": "lib/wmi.js", + "functions": [ + "create", + "execQuery", + "setClass" + ] + }, + { + "module": "lib/xml.js", + "functions": [ + "create", + "load", + "encode", + "decode" + ] + } ] } -} \ No newline at end of file +} From ef11f066619ac7b6cc8e55d063f877d3aa06aa0e Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Tue, 10 Feb 2026 11:03:58 +0900 Subject: [PATCH 13/31] Add SPDX header and fix error message Add SPDX license header and project copyright/URL to JsNative.cs for proper licensing metadata. Update JsonRpc2Dispatcher.cs to improve the exception text to "Unsupported JSON-RPC version: ..." (capitalization and hyphen) for a clearer error message when the jsonrpc version is invalid. --- WelsonJS.Augmented/WelsonJS.Launcher/JsNative.cs | 7 ++++++- WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsNative.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsNative.cs index 3f44823..a5ed2a0 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/JsNative.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsNative.cs @@ -1,4 +1,9 @@ -using System; +// JsNative.cs +// SPDX-License-Identifier: GPL-3.0-or-later +// SPDX-FileCopyrightText: 2025 Catswords OSS and WelsonJS Contributors +// https://github.com/gnh1201/welsonjs +// +using System; using System.Runtime.InteropServices; namespace WelsonJS.Launcher diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs index 5df4c4a..4f5695b 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs @@ -50,7 +50,7 @@ namespace WelsonJS.Launcher { string version = ser.ExtractFrom(id, "jsonrpc"); if (!string.Equals(version, "2.0", StringComparison.Ordinal)) - throw new JsonRpc2Exception("Unsupported jsonrpc version: " + version); + throw new JsonRpc2Exception("Unsupported JSON-RPC version: " + version); string method = ser.ExtractFrom(id, "method"); if (string.IsNullOrEmpty(method)) From aaac19406b29eca2fdebd338e8a5138e1d6b9d5a Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Wed, 11 Feb 2026 16:36:48 +0900 Subject: [PATCH 14/31] Use HTTP SERP API client for search Replace the old JsonRpc2 relay-based product search with a direct HTTP client call to a SERP API endpoint. The search function signature changed from search(s) to search(keyword, limit) and now sends a GET to the workers.dev /api/v1/products/search endpoint with keyword and limit parameters, returning the HTTP responseBody. Also updated VERSIONINFO and removed the previous security notice and remote script relay logic. Note: callers must update usages due to the signature and return-value change. --- lib/coupang.js | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/lib/coupang.js b/lib/coupang.js index 10b5252..12df212 100644 --- a/lib/coupang.js +++ b/lib/coupang.js @@ -1,33 +1,29 @@ // coupang.js +// Coupang SERP API Client // Copyright 2019-2025, Namhyeon Go and the WelsonJS contributors. // SPDX-License-Identifier: GPL-3.0-or-later // https://github.com/gnh1201/welsonjs // -// SECURITY NOTICE -// Due to potential security issues, the Public API URL is not provided. If you need to request access, please refer to the project's contact information. -// You can download the server-side script that implements this functionality from the link below: -// https://github.com/gnh1201/caterpillar -// -var JsonRpc2 = require("lib/jsonrpc2"); +var HTTP = require("lib/http"); -function search(s) { - var rpc = JsonRpc2.create(JsonRpc2.DEFAULT_JSONRPC2_URL); - var result = rpc.invoke("relay_invoke_method", { - "callback": "load_script", - "requires": [ - "https://scriptas.catswords.net/coupang.class.php" - ], - "args": [ - "$search = new CoupangProductSearch(); return $search->searchProducts('" + s + "')" - ] - }, ""); +function search(keyword, limit) { + limit = (typeof limit !== "number" && limit > 0 ? 10 : limit); - return result.data; + return HTTP.create() + .setParameters({ + "keyword": keyword, + "limit": limit + }) + .setDataType("json") + .open("GET", "https://cold-math-31f3.gnh1201.workers.dev/api/v1/products/search") + .send() + .responseBody + ; } exports.search = search; -exports.VERSIONINFO = "Coupang Product Search Client (coupang.js) version 0.1.1"; +exports.VERSIONINFO = "Coupang SERP API Client (coupang.js) version 1.0"; exports.AUTHOR = "gnh1201@catswords.re.kr"; exports.global = global; exports.require = global.require; From 4101c036598e5a9e4b11a77516ddaf6e55bb0725 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Wed, 11 Feb 2026 16:46:37 +0900 Subject: [PATCH 15/31] Validate keyword and normalize limit in search Add input validation to search(): require keyword be a non-empty string and throw a TypeError if not. Normalize limit to a finite integer between 1 and 100 (default 10) using Math.floor and Math.min/Math.max to prevent invalid or out-of-range values. --- lib/coupang.js | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/lib/coupang.js b/lib/coupang.js index 12df212..aab477d 100644 --- a/lib/coupang.js +++ b/lib/coupang.js @@ -7,7 +7,13 @@ var HTTP = require("lib/http"); function search(keyword, limit) { - limit = (typeof limit !== "number" && limit > 0 ? 10 : limit); + if (typeof keyword !== "string" || keyword.length === 0) { + throw new TypeError("keyword must be a non-empty string"); + } + + limit = Math.min(100, Math.max(1, + Math.floor((typeof limit === "number" && isFinite(limit)) ? limit : 10) + )); return HTTP.create() .setParameters({ From d7f58a9b0ce7d8de745b7e151f9965f08377e7df Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Sat, 7 Mar 2026 14:44:14 +0900 Subject: [PATCH 16/31] Propagate request id and add tools call handler Forward the JSON-RPC request id through the dispatcher and handler so methods can access the id. JsonRpc2Dispatcher now passes the id to dispatchMethodAsync, and the JsonRpc2 endpoint lambda accepts the id parameter. Implemented a call for "tools/call" that extracts the tool name via ser.ExtractFrom(id, "params", "name") and invokes a new ResolveToolsCall(string) stub (TODO: implement actual tool logic). This prepares the codepath for tooling invocation based on request params. --- .../WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs | 9 +++++++-- .../WelsonJS.Launcher/JsonRpc2Dispatcher.cs | 2 +- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs index 5964ee5..05aded7 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs @@ -74,7 +74,7 @@ namespace WelsonJS.Launcher.ApiEndpoints { await dispatcher.HandleAsync( body, - async (method, ser, ct) => + async (method, id, ser, ct) => { switch (method) { @@ -83,7 +83,7 @@ namespace WelsonJS.Launcher.ApiEndpoints break; case "tools/call": - // TODO: implement tool calling + await ResolveToolsCall(ser.ExtractFrom(id, "params", "name")); break; } @@ -92,5 +92,10 @@ namespace WelsonJS.Launcher.ApiEndpoints cts.Token); } } + + private async Task ResolveToolsCall(string toolsName) + { + // TODO: ex) get_weather + } } } diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs index 4f5695b..18341f3 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs @@ -62,7 +62,7 @@ namespace WelsonJS.Launcher Method = method }; - return await dispatchMethodAsync(req.Method, ser, ct); + return await dispatchMethodAsync(req.Method, id, ser, ct); } catch (JsonRpc2Exception) { From 3eea89f5a3233ab13345716b0304721aeb88aa44 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 16 Mar 2026 21:17:51 +0900 Subject: [PATCH 17/31] Fix JSON-RPC dispatcher callback params Reordered the parameters for the JSON-RPC dispatch callback to ensure the serializer and request id are passed in the correct positions. Updated the Func signature in JsonRpc2Dispatcher.cs to include the int id parameter before the CancellationToken, and adjusted the invocation/lambda in JsonRpc2.cs to match (method, ser, id, ct), preventing parameter mismatches when handling requests. --- WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs | 2 +- WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs index 05aded7..af9aaa0 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs @@ -74,7 +74,7 @@ namespace WelsonJS.Launcher.ApiEndpoints { await dispatcher.HandleAsync( body, - async (method, id, ser, ct) => + async (method, ser, id, ct) => { switch (method) { diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs index 18341f3..deaee34 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/JsonRpc2Dispatcher.cs @@ -33,7 +33,7 @@ namespace WelsonJS.Launcher public async Task HandleAsync( string requestBody, - Func> dispatchMethodAsync, + Func> dispatchMethodAsync, CancellationToken ct) { if (string.IsNullOrEmpty(requestBody)) @@ -62,7 +62,7 @@ namespace WelsonJS.Launcher Method = method }; - return await dispatchMethodAsync(req.Method, id, ser, ct); + return await dispatchMethodAsync(req.Method, ser, id, ct); } catch (JsonRpc2Exception) { From f1456e304c40b35e7f4b20a752b4f7b5b986d965 Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Mon, 16 Mar 2026 21:37:16 +0900 Subject: [PATCH 18/31] Add tools call handling and translate docs Pass the serializer and request id to ResolveToolsCall and implement a basic dispatcher that extracts params.method. Add a handler stub for "run_jsrt_script" (extracts the script argument; implementation TODO) and log unknown tool methods. Also update McpToolsList.json scriptContract notes from Korean to English to improve readability/localization. --- .../ApiEndpoints/JsonRpc2.cs | 21 ++++++++++++++++--- .../WelsonJS.Launcher/McpToolsList.json | 4 ++-- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs index af9aaa0..a410c68 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs +++ b/WelsonJS.Augmented/WelsonJS.Launcher/ApiEndpoints/JsonRpc2.cs @@ -83,7 +83,7 @@ namespace WelsonJS.Launcher.ApiEndpoints break; case "tools/call": - await ResolveToolsCall(ser.ExtractFrom(id, "params", "name")); + await ResolveToolsCall(ser, id); break; } @@ -93,9 +93,24 @@ namespace WelsonJS.Launcher.ApiEndpoints } } - private async Task ResolveToolsCall(string toolsName) + private async Task ResolveToolsCall(JsSerializer ser, int id) { - // TODO: ex) get_weather + var toolsName = ser.ExtractFrom(id, "params", "method")?.Trim(); + + switch (toolsName) + { + case "run_jsrt_script": + { + var script = ser.ExtractFrom(id, "params", "arguments", "script")?.Trim(); + + // todo + } + break; + + default: + _logger.Warn($"[JsonRpc2] Unknown tools method: {toolsName}"); + break; + } } } } diff --git a/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json b/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json index 6718e2c..c197e33 100644 --- a/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json +++ b/WelsonJS.Augmented/WelsonJS.Launcher/McpToolsList.json @@ -10,8 +10,8 @@ "scriptContract": { "requiredEntryPoint": "function main(args) { /* ... */ }; exports.main = main;", "notes": [ - "모든 실행 스크립트 결과물은 main 함수를 export해야 합니다.", - "ES3 문법을 기본으로 작성하고, 필요한 경우 ES5 polyfill 범위 내에서만 확장하세요." + "All executable script outputs must export a main function.", + "Write using ES3 syntax by default, and extend only within the ES5 polyfill scope if necessary." ] }, "tools": [ From 2599470bb603bbac9da36808f87665876f15c16d Mon Sep 17 00:00:00 2001 From: stackgo Date: Thu, 9 Apr 2026 16:30:17 +0900 Subject: [PATCH 19/31] Add stdin flag to console and update copyright app.js: Add a _useStdin flag (via WScript.Arguments.Named.Exists("stdin")) and skip default echoing when stdin is in use; switch WScript.Echo to WScript.StdOut.WriteLine for proper stdout output. Remove separator comment lines before initializeConsole. bootstrap.js: Bump copyright year to 2026 and remove an obsolete/commented CORS-to-ADO registry tweak. These changes improve console output behavior for piped input and clean up bootstrap metadata and comments. --- app.js | 16 +++++++++++----- bootstrap.js | 7 +------ 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/app.js b/app.js index 57f88eb..1b61072 100644 --- a/app.js +++ b/app.js @@ -36,9 +36,18 @@ var console = { } return res; }, - _echoDefault: function(message) { + _useStdin: (function() { if (typeof WScript !== "undefined") { - WScript.Echo("[*] " + message) + return WScript.Arguments.Named.Exists("stdin"); + } + return false; + })(), + _echoDefault: function(message) { + if (this._useStdin) + return; + + if (typeof WScript !== "undefined") { + WScript.StdOut.WriteLine("[*] " + message); } }, _echoCallback: null, @@ -715,10 +724,7 @@ require._addScriptProvider = function(f) { } }; -///////////////////////////////////////////////////////////////////////////////// // Load script, and call app.main() -///////////////////////////////////////////////////////////////////////////////// - function initializeConsole() { if (typeof WScript === "undefined") { console.error("This is not a console application"); diff --git a/bootstrap.js b/bootstrap.js index 0e7d919..8b5c330 100644 --- a/bootstrap.js +++ b/bootstrap.js @@ -1,5 +1,5 @@ // bootstrap.js -// Copyright 2019-2025, Namhyeon Go and the WelsonJS contributors. +// Copyright 2019-2026, Namhyeon Go and the WelsonJS contributors. // SPDX-License-Identifier: GPL-3.0-or-later // https://github.com/gnh1201/welsonjs // @@ -19,11 +19,6 @@ function main(args) { console.log("Starting unlock files..."); PS.execCommand("dir | Unblock-File"); - // Allow CROS to ADO - //console.log("Adjusting CROS policy to ADO..."); - //REG.write(REG.HKCU, "SOFTWARE\\Policies\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Lockdown_Zones\\4", "1406", "00000000", REG.DWORD); - //REG.write(REG.HKLM, "SOFTWARE\\Policies\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Lockdown_Zones\\4", "1406", "00000000", REG.DWORD); - // Register HTA file association console.log("Registering HTA file association..."); REG.execFile("app\\assets\\reg\\Default_HTA.reg"); From fe21be0e54432172c754da92308e003673967ac4 Mon Sep 17 00:00:00 2001 From: stackgo Date: Sat, 11 Apr 2026 12:36:03 +0900 Subject: [PATCH 20/31] Add core-js 3.49.0 bundle Add new webpacked core-js bundle (app/assets/js/core-js-3.49.0.wsh.js) containing core-js v3.49.0 polyfills and runtime helpers. The file includes the webpack bootstrap and numerous core-js modules to provide compatibility for older environments (license and source referenced in header). --- app/assets/js/core-js-3.49.0.wsh.js | 29381 ++++++++++++++++++++++++++ 1 file changed, 29381 insertions(+) create mode 100644 app/assets/js/core-js-3.49.0.wsh.js diff --git a/app/assets/js/core-js-3.49.0.wsh.js b/app/assets/js/core-js-3.49.0.wsh.js new file mode 100644 index 0000000..212a995 --- /dev/null +++ b/app/assets/js/core-js-3.49.0.wsh.js @@ -0,0 +1,29381 @@ +/** + * core-js 3.49.0 + * © 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved. + * license: https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE + * source: https://github.com/zloirock/core-js + */ +!function (undefined) { 'use strict'; /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ var __webpack_require__ = function (moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +__webpack_require__(1); +__webpack_require__(100); +__webpack_require__(101); +__webpack_require__(102); +__webpack_require__(103); +__webpack_require__(104); +__webpack_require__(105); +__webpack_require__(106); +__webpack_require__(107); +__webpack_require__(108); +__webpack_require__(109); +__webpack_require__(110); +__webpack_require__(111); +__webpack_require__(112); +__webpack_require__(113); +__webpack_require__(114); +__webpack_require__(115); +__webpack_require__(116); +__webpack_require__(129); +__webpack_require__(130); +__webpack_require__(132); +__webpack_require__(142); +__webpack_require__(143); +__webpack_require__(144); +__webpack_require__(146); +__webpack_require__(150); +__webpack_require__(153); +__webpack_require__(155); +__webpack_require__(157); +__webpack_require__(158); +__webpack_require__(159); +__webpack_require__(160); +__webpack_require__(162); +__webpack_require__(163); +__webpack_require__(165); +__webpack_require__(166); +__webpack_require__(168); +__webpack_require__(172); +__webpack_require__(173); +__webpack_require__(174); +__webpack_require__(175); +__webpack_require__(180); +__webpack_require__(181); +__webpack_require__(183); +__webpack_require__(184); +__webpack_require__(185); +__webpack_require__(186); +__webpack_require__(190); +__webpack_require__(191); +__webpack_require__(192); +__webpack_require__(193); +__webpack_require__(194); +__webpack_require__(199); +__webpack_require__(201); +__webpack_require__(202); +__webpack_require__(203); +__webpack_require__(206); +__webpack_require__(207); +__webpack_require__(208); +__webpack_require__(209); +__webpack_require__(210); +__webpack_require__(211); +__webpack_require__(222); +__webpack_require__(224); +__webpack_require__(225); +__webpack_require__(227); +__webpack_require__(228); +__webpack_require__(231); +__webpack_require__(234); +__webpack_require__(240); +__webpack_require__(241); +__webpack_require__(242); +__webpack_require__(243); +__webpack_require__(244); +__webpack_require__(245); +__webpack_require__(249); +__webpack_require__(250); +__webpack_require__(252); +__webpack_require__(253); +__webpack_require__(255); +__webpack_require__(256); +__webpack_require__(258); +__webpack_require__(259); +__webpack_require__(260); +__webpack_require__(261); +__webpack_require__(262); +__webpack_require__(265); +__webpack_require__(266); +__webpack_require__(272); +__webpack_require__(273); +__webpack_require__(274); +__webpack_require__(275); +__webpack_require__(277); +__webpack_require__(278); +__webpack_require__(279); +__webpack_require__(280); +__webpack_require__(281); +__webpack_require__(282); +__webpack_require__(283); +__webpack_require__(284); +__webpack_require__(285); +__webpack_require__(286); +__webpack_require__(94); +__webpack_require__(288); +__webpack_require__(289); +__webpack_require__(296); +__webpack_require__(298); +__webpack_require__(299); +__webpack_require__(300); +__webpack_require__(302); +__webpack_require__(303); +__webpack_require__(304); +__webpack_require__(305); +__webpack_require__(306); +__webpack_require__(308); +__webpack_require__(309); +__webpack_require__(310); +__webpack_require__(311); +__webpack_require__(312); +__webpack_require__(313); +__webpack_require__(315); +__webpack_require__(316); +__webpack_require__(317); +__webpack_require__(318); +__webpack_require__(319); +__webpack_require__(320); +__webpack_require__(321); +__webpack_require__(322); +__webpack_require__(323); +__webpack_require__(327); +__webpack_require__(328); +__webpack_require__(330); +__webpack_require__(332); +__webpack_require__(333); +__webpack_require__(334); +__webpack_require__(335); +__webpack_require__(336); +__webpack_require__(338); +__webpack_require__(340); +__webpack_require__(341); +__webpack_require__(342); +__webpack_require__(343); +__webpack_require__(345); +__webpack_require__(346); +__webpack_require__(348); +__webpack_require__(349); +__webpack_require__(350); +__webpack_require__(351); +__webpack_require__(353); +__webpack_require__(354); +__webpack_require__(355); +__webpack_require__(356); +__webpack_require__(357); +__webpack_require__(358); +__webpack_require__(359); +__webpack_require__(360); +__webpack_require__(361); +__webpack_require__(363); +__webpack_require__(364); +__webpack_require__(365); +__webpack_require__(366); +__webpack_require__(367); +__webpack_require__(368); +__webpack_require__(369); +__webpack_require__(370); +__webpack_require__(371); +__webpack_require__(372); +__webpack_require__(373); +__webpack_require__(375); +__webpack_require__(376); +__webpack_require__(377); +__webpack_require__(378); +__webpack_require__(402); +__webpack_require__(403); +__webpack_require__(404); +__webpack_require__(405); +__webpack_require__(406); +__webpack_require__(407); +__webpack_require__(414); +__webpack_require__(415); +__webpack_require__(416); +__webpack_require__(417); +__webpack_require__(418); +__webpack_require__(419); +__webpack_require__(420); +__webpack_require__(422); +__webpack_require__(423); +__webpack_require__(424); +__webpack_require__(425); +__webpack_require__(426); +__webpack_require__(427); +__webpack_require__(428); +__webpack_require__(429); +__webpack_require__(430); +__webpack_require__(431); +__webpack_require__(439); +__webpack_require__(441); +__webpack_require__(442); +__webpack_require__(444); +__webpack_require__(445); +__webpack_require__(446); +__webpack_require__(447); +__webpack_require__(448); +__webpack_require__(450); +__webpack_require__(460); +__webpack_require__(462); +__webpack_require__(464); +__webpack_require__(466); +__webpack_require__(468); +__webpack_require__(471); +__webpack_require__(473); +__webpack_require__(474); +__webpack_require__(476); +__webpack_require__(479); +__webpack_require__(480); +__webpack_require__(481); +__webpack_require__(482); +__webpack_require__(483); +__webpack_require__(487); +__webpack_require__(488); +__webpack_require__(490); +__webpack_require__(491); +__webpack_require__(492); +__webpack_require__(493); +__webpack_require__(495); +__webpack_require__(496); +__webpack_require__(497); +__webpack_require__(498); +__webpack_require__(499); +__webpack_require__(500); +__webpack_require__(501); +__webpack_require__(503); +__webpack_require__(506); +__webpack_require__(509); +__webpack_require__(512); +__webpack_require__(513); +__webpack_require__(514); +__webpack_require__(515); +__webpack_require__(516); +__webpack_require__(517); +__webpack_require__(518); +__webpack_require__(519); +__webpack_require__(520); +__webpack_require__(521); +__webpack_require__(522); +__webpack_require__(523); +__webpack_require__(524); +__webpack_require__(532); +__webpack_require__(533); +__webpack_require__(534); +__webpack_require__(535); +__webpack_require__(536); +__webpack_require__(537); +__webpack_require__(538); +__webpack_require__(539); +__webpack_require__(540); +__webpack_require__(541); +__webpack_require__(542); +__webpack_require__(543); +__webpack_require__(544); +__webpack_require__(546); +__webpack_require__(547); +__webpack_require__(548); +__webpack_require__(549); +__webpack_require__(550); +__webpack_require__(551); +__webpack_require__(552); +__webpack_require__(553); +__webpack_require__(554); +__webpack_require__(555); +__webpack_require__(556); +__webpack_require__(557); +__webpack_require__(558); +__webpack_require__(559); +__webpack_require__(560); +__webpack_require__(561); +__webpack_require__(562); +__webpack_require__(563); +__webpack_require__(564); +__webpack_require__(565); +__webpack_require__(566); +__webpack_require__(567); +__webpack_require__(568); +__webpack_require__(569); +__webpack_require__(570); +__webpack_require__(571); +__webpack_require__(572); +__webpack_require__(577); +__webpack_require__(579); +__webpack_require__(581); +__webpack_require__(582); +__webpack_require__(583); +__webpack_require__(584); +__webpack_require__(585); +__webpack_require__(588); +__webpack_require__(590); +__webpack_require__(593); +__webpack_require__(595); +__webpack_require__(596); +__webpack_require__(597); +__webpack_require__(599); +__webpack_require__(600); +__webpack_require__(602); +__webpack_require__(603); +__webpack_require__(604); +__webpack_require__(605); +__webpack_require__(606); +__webpack_require__(609); +__webpack_require__(610); +__webpack_require__(614); +__webpack_require__(615); +__webpack_require__(616); +__webpack_require__(617); +__webpack_require__(618); +__webpack_require__(620); +__webpack_require__(621); +__webpack_require__(623); +__webpack_require__(624); +__webpack_require__(625); +__webpack_require__(626); +__webpack_require__(627); +__webpack_require__(628); +__webpack_require__(629); +__webpack_require__(631); +__webpack_require__(633); +__webpack_require__(634); +__webpack_require__(635); +__webpack_require__(636); +__webpack_require__(638); +__webpack_require__(639); +__webpack_require__(640); +__webpack_require__(641); +__webpack_require__(642); +__webpack_require__(644); +__webpack_require__(645); +__webpack_require__(646); +__webpack_require__(647); +__webpack_require__(649); +__webpack_require__(650); +__webpack_require__(651); +__webpack_require__(655); +__webpack_require__(656); +__webpack_require__(658); +__webpack_require__(659); +__webpack_require__(660); +__webpack_require__(661); +__webpack_require__(662); +__webpack_require__(663); +__webpack_require__(665); +__webpack_require__(667); +__webpack_require__(668); +__webpack_require__(669); +__webpack_require__(670); +__webpack_require__(671); +__webpack_require__(672); +__webpack_require__(674); +__webpack_require__(675); +__webpack_require__(676); +__webpack_require__(677); +__webpack_require__(679); +__webpack_require__(680); +__webpack_require__(683); +__webpack_require__(684); +__webpack_require__(685); +__webpack_require__(687); +__webpack_require__(688); +__webpack_require__(689); +__webpack_require__(690); +__webpack_require__(691); +__webpack_require__(692); +__webpack_require__(693); +__webpack_require__(694); +__webpack_require__(695); +__webpack_require__(696); +__webpack_require__(697); +__webpack_require__(698); +__webpack_require__(699); +__webpack_require__(701); +__webpack_require__(702); +__webpack_require__(703); +__webpack_require__(707); +__webpack_require__(709); +__webpack_require__(710); +__webpack_require__(711); +__webpack_require__(712); +__webpack_require__(713); +__webpack_require__(714); +__webpack_require__(715); +__webpack_require__(716); +__webpack_require__(717); +__webpack_require__(718); +__webpack_require__(719); +__webpack_require__(722); +__webpack_require__(723); +__webpack_require__(724); +__webpack_require__(725); +__webpack_require__(726); +__webpack_require__(727); +__webpack_require__(728); +__webpack_require__(729); +__webpack_require__(730); +__webpack_require__(731); +__webpack_require__(732); +__webpack_require__(733); +__webpack_require__(734); +__webpack_require__(735); +__webpack_require__(736); +__webpack_require__(737); +__webpack_require__(738); +__webpack_require__(740); +__webpack_require__(741); +__webpack_require__(743); +__webpack_require__(744); +__webpack_require__(746); +__webpack_require__(747); +__webpack_require__(749); +__webpack_require__(750); +__webpack_require__(751); +__webpack_require__(752); +__webpack_require__(753); +__webpack_require__(754); +__webpack_require__(755); +__webpack_require__(756); +__webpack_require__(757); +__webpack_require__(758); +__webpack_require__(759); +__webpack_require__(760); +__webpack_require__(761); +__webpack_require__(762); +__webpack_require__(763); +__webpack_require__(764); +__webpack_require__(765); +__webpack_require__(766); +__webpack_require__(767); +__webpack_require__(770); +__webpack_require__(771); +__webpack_require__(772); +__webpack_require__(773); +__webpack_require__(774); +__webpack_require__(775); +__webpack_require__(778); +__webpack_require__(779); +__webpack_require__(781); +__webpack_require__(782); +__webpack_require__(783); +__webpack_require__(787); +__webpack_require__(788); +__webpack_require__(789); +__webpack_require__(790); +__webpack_require__(793); +__webpack_require__(798); +__webpack_require__(799); +__webpack_require__(800); +__webpack_require__(801); +__webpack_require__(802); +__webpack_require__(803); +module.exports = __webpack_require__(804); + + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's split to modules listed below +__webpack_require__(2); +__webpack_require__(91); +__webpack_require__(93); +__webpack_require__(94); +__webpack_require__(99); + + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var IS_PURE = __webpack_require__(36); +var DESCRIPTORS = __webpack_require__(6); +var NATIVE_SYMBOL = __webpack_require__(26); +var fails = __webpack_require__(7); +var hasOwn = __webpack_require__(38); +var isPrototypeOf = __webpack_require__(24); +var anObject = __webpack_require__(46); +var toIndexedObject = __webpack_require__(12); +var toPropertyKey = __webpack_require__(18); +var $toString = __webpack_require__(68); +var createPropertyDescriptor = __webpack_require__(11); +var nativeObjectCreate = __webpack_require__(71); +var objectKeys = __webpack_require__(73); +var getOwnPropertyNamesModule = __webpack_require__(57); +var getOwnPropertyNamesExternal = __webpack_require__(75); +var getOwnPropertySymbolsModule = __webpack_require__(66); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var definePropertyModule = __webpack_require__(44); +var definePropertiesModule = __webpack_require__(72); +var propertyIsEnumerableModule = __webpack_require__(10); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltInAccessor = __webpack_require__(77); +var shared = __webpack_require__(34); +var sharedKey = __webpack_require__(53); +var hiddenKeys = __webpack_require__(54); +var uid = __webpack_require__(40); +var wellKnownSymbol = __webpack_require__(33); +var wrappedWellKnownSymbolModule = __webpack_require__(78); +var defineWellKnownSymbol = __webpack_require__(79); +var defineSymbolToPrimitive = __webpack_require__(81); +var setToStringTag = __webpack_require__(82); +var InternalStateModule = __webpack_require__(51); +var $forEach = __webpack_require__(83).forEach; + +var HIDDEN = sharedKey('hidden'); +var SYMBOL = 'Symbol'; +var PROTOTYPE = 'prototype'; + +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(SYMBOL); + +var ObjectPrototype = Object[PROTOTYPE]; +var $Symbol = globalThis.Symbol; +var SymbolPrototype = $Symbol && $Symbol[PROTOTYPE]; +var RangeError = globalThis.RangeError; +var TypeError = globalThis.TypeError; +var QObject = globalThis.QObject; +var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; +var nativeDefineProperty = definePropertyModule.f; +var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f; +var nativePropertyIsEnumerable = propertyIsEnumerableModule.f; +var push = uncurryThis([].push); + +var AllSymbols = shared('symbols'); +var ObjectPrototypeSymbols = shared('op-symbols'); +var WellKnownSymbolsStore = shared('wks'); + +// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 +var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; + +// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 +var fallbackDefineProperty = function (O, P, Attributes) { + var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P); + if (ObjectPrototypeDescriptor) delete ObjectPrototype[P]; + nativeDefineProperty(O, P, Attributes); + if (ObjectPrototypeDescriptor && O !== ObjectPrototype) { + nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor); + } return O; +}; + +var setSymbolDescriptor = DESCRIPTORS && fails(function () { + return nativeObjectCreate(nativeDefineProperty({}, 'a', { + get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; } + })).a !== 7; +}) ? fallbackDefineProperty : nativeDefineProperty; + +var wrap = function (tag, description) { + var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype); + setInternalState(symbol, { + type: SYMBOL, + tag: tag, + description: description + }); + if (!DESCRIPTORS) symbol.description = description; + return symbol; +}; + +var $defineProperty = function defineProperty(O, P, Attributes) { + if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes); + anObject(O); + var key = toPropertyKey(P); + anObject(Attributes); + if (hasOwn(AllSymbols, key)) { + // first definition - default non-enumerable; redefinition - preserve existing state + if (!('enumerable' in Attributes) ? !hasOwn(O, key) || (hasOwn(O, HIDDEN) && O[HIDDEN][key]) : !Attributes.enumerable) { + if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, nativeObjectCreate(null))); + O[HIDDEN][key] = true; + } else { + if (hasOwn(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false; + Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) }); + } return setSymbolDescriptor(O, key, Attributes); + } return nativeDefineProperty(O, key, Attributes); +}; + +var $defineProperties = function defineProperties(O, Properties) { + anObject(O); + var properties = toIndexedObject(Properties); + var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties)); + $forEach(keys, function (key) { + if (!DESCRIPTORS || call($propertyIsEnumerable, properties, key)) $defineProperty(O, key, properties[key]); + }); + return O; +}; + +var $create = function create(O, Properties) { + return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties); +}; + +var $propertyIsEnumerable = function propertyIsEnumerable(V) { + var P = toPropertyKey(V); + var enumerable = call(nativePropertyIsEnumerable, this, P); + if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P)) return false; + return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P] + ? enumerable : true; +}; + +var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) { + var it = toIndexedObject(O); + var key = toPropertyKey(P); + if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key)) return; + var descriptor = nativeGetOwnPropertyDescriptor(it, key); + if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(it, HIDDEN) && it[HIDDEN][key])) { + descriptor.enumerable = true; + } + return descriptor; +}; + +var $getOwnPropertyNames = function getOwnPropertyNames(O) { + var names = nativeGetOwnPropertyNames(toIndexedObject(O)); + var result = []; + $forEach(names, function (key) { + if (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key)) push(result, key); + }); + return result; +}; + +var $getOwnPropertySymbols = function (O) { + var IS_OBJECT_PROTOTYPE = O === ObjectPrototype; + var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O)); + var result = []; + $forEach(names, function (key) { + if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) { + push(result, AllSymbols[key]); + } + }); + return result; +}; + +// `Symbol` constructor +// https://tc39.es/ecma262/#sec-symbol-constructor +if (!NATIVE_SYMBOL) { + $Symbol = function Symbol() { + if (isPrototypeOf(SymbolPrototype, this)) throw new TypeError('Symbol is not a constructor'); + var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]); + var tag = uid(description); + var setter = function (value) { + var $this = this === undefined ? globalThis : this; + if ($this === ObjectPrototype) call(setter, ObjectPrototypeSymbols, value); + if (hasOwn($this, HIDDEN) && hasOwn($this[HIDDEN], tag)) $this[HIDDEN][tag] = false; + var descriptor = createPropertyDescriptor(1, value); + try { + setSymbolDescriptor($this, tag, descriptor); + } catch (error) { + if (!(error instanceof RangeError)) throw error; + fallbackDefineProperty($this, tag, descriptor); + } + }; + if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter }); + return wrap(tag, description); + }; + + SymbolPrototype = $Symbol[PROTOTYPE]; + + defineBuiltIn(SymbolPrototype, 'toString', function toString() { + return getInternalState(this).tag; + }); + + defineBuiltIn($Symbol, 'withoutSetter', function (description) { + return wrap(uid(description), description); + }); + + propertyIsEnumerableModule.f = $propertyIsEnumerable; + definePropertyModule.f = $defineProperty; + definePropertiesModule.f = $defineProperties; + getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor; + getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames; + getOwnPropertySymbolsModule.f = $getOwnPropertySymbols; + + wrappedWellKnownSymbolModule.f = function (name) { + return wrap(wellKnownSymbol(name), name); + }; + + if (DESCRIPTORS) { + // https://tc39.es/ecma262/#sec-symbol.prototype.description + defineBuiltInAccessor(SymbolPrototype, 'description', { + configurable: true, + get: function description() { + return getInternalState(this).description; + } + }); + if (!IS_PURE) { + defineBuiltIn(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); + } + } +} + +$({ global: true, constructor: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, { + Symbol: $Symbol +}); + +$forEach(objectKeys(WellKnownSymbolsStore), function (name) { + defineWellKnownSymbol(name); +}); + +$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, { + useSetter: function () { USE_SETTER = true; }, + useSimple: function () { USE_SETTER = false; } +}); + +$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, { + // `Object.create` method + // https://tc39.es/ecma262/#sec-object.create + create: $create, + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + defineProperty: $defineProperty, + // `Object.defineProperties` method + // https://tc39.es/ecma262/#sec-object.defineproperties + defineProperties: $defineProperties, + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptors + getOwnPropertyDescriptor: $getOwnPropertyDescriptor +}); + +$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, { + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + getOwnPropertyNames: $getOwnPropertyNames +}); + +// `Symbol.prototype[@@toPrimitive]` method +// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive +defineSymbolToPrimitive(); + +// `Symbol.prototype[@@toStringTag]` property +// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag +setToStringTag($Symbol, SYMBOL); + +hiddenKeys[HIDDEN] = true; + + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var createNonEnumerableProperty = __webpack_require__(43); +var defineBuiltIn = __webpack_require__(47); +var defineGlobalProperty = __webpack_require__(37); +var copyConstructorProperties = __webpack_require__(55); +var isForced = __webpack_require__(67); + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +module.exports = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = globalThis; + } else if (STATIC) { + target = globalThis[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = globalThis[TARGET] && globalThis[TARGET].prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + defineBuiltIn(target, key, sourceProperty, options); + } +}; + + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +module.exports = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof global == 'object' && global) || + check(typeof this == 'object' && this) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var call = __webpack_require__(8); +var propertyIsEnumerableModule = __webpack_require__(10); +var createPropertyDescriptor = __webpack_require__(11); +var toIndexedObject = __webpack_require__(12); +var toPropertyKey = __webpack_require__(18); +var hasOwn = __webpack_require__(38); +var IE8_DOM_DEFINE = __webpack_require__(41); + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); +}; + + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +// Detect IE8's incomplete defineProperty implementation +module.exports = !fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_BIND = __webpack_require__(9); + +var call = Function.prototype.call; +// eslint-disable-next-line es/no-function-prototype-bind -- safe +module.exports = NATIVE_BIND ? call.bind(call) : function () { + return call.apply(call, arguments); +}; + + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = function () { /* empty */ }.bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $propertyIsEnumerable = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable; + + +/***/ }), +/* 11 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + + +/***/ }), +/* 12 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject = __webpack_require__(13); +var requireObjectCoercible = __webpack_require__(16); + +module.exports = function (it) { + return IndexedObject(requireObjectCoercible(it)); +}; + + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var classof = __webpack_require__(15); + +var $Object = Object; +var split = uncurryThis(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +module.exports = fails(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof(it) === 'String' ? split(it, '') : $Object(it); +} : $Object; + + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_BIND = __webpack_require__(9); + +var FunctionPrototype = Function.prototype; +var call = FunctionPrototype.call; +// eslint-disable-next-line es/no-function-prototype-bind -- safe +var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call); + +module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) { + return function () { + return call.apply(fn, arguments); + }; +}; + + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +var toString = uncurryThis({}.toString); +var stringSlice = uncurryThis(''.slice); + +module.exports = function (it) { + return stringSlice(toString(it), 8, -1); +}; + + +/***/ }), +/* 16 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isNullOrUndefined = __webpack_require__(17); + +var $TypeError = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +module.exports = function (it) { + if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it); + return it; +}; + + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +module.exports = function (it) { + return it === null || it === undefined; +}; + + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toPrimitive = __webpack_require__(19); +var isSymbol = __webpack_require__(22); + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +module.exports = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + + +/***/ }), +/* 19 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var isObject = __webpack_require__(20); +var isSymbol = __webpack_require__(22); +var getMethod = __webpack_require__(29); +var ordinaryToPrimitive = __webpack_require__(32); +var wellKnownSymbol = __webpack_require__(33); + +var $TypeError = TypeError; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +module.exports = function (input, pref) { + if (!isObject(input) || isSymbol(input)) return input; + var exoticToPrim = getMethod(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call(exoticToPrim, input, pref); + if (!isObject(result) || isSymbol(result)) return result; + throw new $TypeError("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + + +/***/ }), +/* 20 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(21); + +module.exports = function (it) { + return typeof it == 'object' ? it !== null : isCallable(it); +}; + + +/***/ }), +/* 21 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +var documentAll = typeof document == 'object' && document.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) { + return typeof argument == 'function' || argument === documentAll; +} : function (argument) { + return typeof argument == 'function'; +}; + + +/***/ }), +/* 22 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var isCallable = __webpack_require__(21); +var isPrototypeOf = __webpack_require__(24); +var USE_SYMBOL_AS_UID = __webpack_require__(25); + +var $Object = Object; + +module.exports = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn('Symbol'); + return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it)); +}; + + +/***/ }), +/* 23 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var isCallable = __webpack_require__(21); + +var aFunction = function (argument) { + return isCallable(argument) ? argument : undefined; +}; + +module.exports = function (namespace, method) { + return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method]; +}; + + +/***/ }), +/* 24 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +module.exports = uncurryThis({}.isPrototypeOf); + + +/***/ }), +/* 25 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL = __webpack_require__(26); + +module.exports = NATIVE_SYMBOL && + !Symbol.sham && + typeof Symbol.iterator == 'symbol'; + + +/***/ }), +/* 26 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION = __webpack_require__(27); +var fails = __webpack_require__(7); +var globalThis = __webpack_require__(4); + +var $String = globalThis.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +module.exports = !!Object.getOwnPropertySymbols && !fails(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION && V8_VERSION < 41; +}); + + +/***/ }), +/* 27 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var userAgent = __webpack_require__(28); + +var process = globalThis.process; +var Deno = globalThis.Deno; +var versions = process && process.versions || Deno && Deno.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +module.exports = version; + + +/***/ }), +/* 28 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +var navigator = globalThis.navigator; +var userAgent = navigator && navigator.userAgent; + +module.exports = userAgent ? String(userAgent) : ''; + + +/***/ }), +/* 29 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aCallable = __webpack_require__(30); +var isNullOrUndefined = __webpack_require__(17); + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +module.exports = function (V, P) { + var func = V[P]; + return isNullOrUndefined(func) ? undefined : aCallable(func); +}; + + +/***/ }), +/* 30 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(21); +var tryToString = __webpack_require__(31); + +var $TypeError = TypeError; + +// `Assert: IsCallable(argument) is true` +module.exports = function (argument) { + if (isCallable(argument)) return argument; + throw new $TypeError(tryToString(argument) + ' is not a function'); +}; + + +/***/ }), +/* 31 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $String = String; + +module.exports = function (argument) { + try { + return $String(argument); + } catch (error) { + return 'Object'; + } +}; + + +/***/ }), +/* 32 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); + +var $TypeError = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +module.exports = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; + if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val; + if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; + throw new $TypeError("Can't convert object to primitive value"); +}; + + +/***/ }), +/* 33 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var shared = __webpack_require__(34); +var hasOwn = __webpack_require__(38); +var uid = __webpack_require__(40); +var NATIVE_SYMBOL = __webpack_require__(26); +var USE_SYMBOL_AS_UID = __webpack_require__(25); + +var Symbol = globalThis.Symbol; +var WellKnownSymbolsStore = shared('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid; + +module.exports = function (name) { + if (!hasOwn(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) + ? Symbol[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + + +/***/ }), +/* 34 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var store = __webpack_require__(35); + +module.exports = function (key, value) { + return store[key] || (store[key] = value || {}); +}; + + +/***/ }), +/* 35 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var IS_PURE = __webpack_require__(36); +var globalThis = __webpack_require__(4); +var defineGlobalProperty = __webpack_require__(37); + +var SHARED = '__core-js_shared__'; +var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {}); + +(store.versions || (store.versions = [])).push({ + version: '3.49.0', + mode: IS_PURE ? 'pure' : 'global', + copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.', + license: 'https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + + +/***/ }), +/* 36 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = false; + + +/***/ }), +/* 37 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty = Object.defineProperty; + +module.exports = function (key, value) { + try { + defineProperty(globalThis, key, { value: value, configurable: true, writable: true }); + } catch (error) { + globalThis[key] = value; + } return value; +}; + + +/***/ }), +/* 38 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var toObject = __webpack_require__(39); + +var hasOwnProperty = uncurryThis({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +module.exports = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject(it), key); +}; + + +/***/ }), +/* 39 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var requireObjectCoercible = __webpack_require__(16); + +var $Object = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +module.exports = function (argument) { + return $Object(requireObjectCoercible(argument)); +}; + + +/***/ }), +/* 40 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +var id = 0; +var postfix = Math.random(); +var toString = uncurryThis(1.1.toString); + +module.exports = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36); +}; + + +/***/ }), +/* 41 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var createElement = __webpack_require__(42); + +// Thanks to IE8 for its funny defineProperty +module.exports = !DESCRIPTORS && !fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + + +/***/ }), +/* 42 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var isObject = __webpack_require__(20); + +var document = globalThis.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject(document) && isObject(document.createElement); + +module.exports = function (it) { + return EXISTS ? document.createElement(it) : {}; +}; + + +/***/ }), +/* 43 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var definePropertyModule = __webpack_require__(44); +var createPropertyDescriptor = __webpack_require__(11); + +module.exports = DESCRIPTORS ? function (object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + + +/***/ }), +/* 44 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var IE8_DOM_DEFINE = __webpack_require__(41); +var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(45); +var anObject = __webpack_require__(46); +var toPropertyKey = __webpack_require__(18); + +var $TypeError = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + + +/***/ }), +/* 45 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +module.exports = DESCRIPTORS && fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + + +/***/ }), +/* 46 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); + +var $String = String; +var $TypeError = TypeError; + +// `Assert: Type(argument) is Object` +module.exports = function (argument) { + if (isObject(argument)) return argument; + throw new $TypeError($String(argument) + ' is not an object'); +}; + + +/***/ }), +/* 47 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(21); +var definePropertyModule = __webpack_require__(44); +var makeBuiltIn = __webpack_require__(48); +var defineGlobalProperty = __webpack_require__(37); + +module.exports = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + + +/***/ }), +/* 48 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var isCallable = __webpack_require__(21); +var hasOwn = __webpack_require__(38); +var DESCRIPTORS = __webpack_require__(6); +var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(49).CONFIGURABLE; +var inspectSource = __webpack_require__(50); +var InternalStateModule = __webpack_require__(51); + +var enforceInternalState = InternalStateModule.enforce; +var getInternalState = InternalStateModule.get; +var $String = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty = Object.defineProperty; +var stringSlice = uncurryThis(''.slice); +var replace = uncurryThis(''.replace); +var join = uncurryThis([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () { + return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn = module.exports = function (value, name, options) { + if (stringSlice($String(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) { + if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) { + defineProperty(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn(options, 'constructor') && options.constructor) { + if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn(function toString() { + return isCallable(this) && getInternalState(this).source || inspectSource(this); +}, 'toString'); + + +/***/ }), +/* 49 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var hasOwn = __webpack_require__(38); + +var FunctionPrototype = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor; + +var EXISTS = hasOwn(FunctionPrototype, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS && function something() { /* empty */ }.name === 'something'; +var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable)); + +module.exports = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE +}; + + +/***/ }), +/* 50 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var isCallable = __webpack_require__(21); +var store = __webpack_require__(35); + +var functionToString = uncurryThis(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable(store.inspectSource)) { + store.inspectSource = function (it) { + return functionToString(it); + }; +} + +module.exports = store.inspectSource; + + +/***/ }), +/* 51 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_WEAK_MAP = __webpack_require__(52); +var globalThis = __webpack_require__(4); +var isObject = __webpack_require__(20); +var createNonEnumerableProperty = __webpack_require__(43); +var hasOwn = __webpack_require__(38); +var shared = __webpack_require__(35); +var sharedKey = __webpack_require__(53); +var hiddenKeys = __webpack_require__(54); + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError = globalThis.TypeError; +var WeakMap = globalThis.WeakMap; +var set, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw new TypeError('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set = function (it, metadata) { + if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys[STATE] = true; + set = function (it, metadata) { + if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn(it, STATE); + }; +} + +module.exports = { + set: set, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + + +/***/ }), +/* 52 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var isCallable = __webpack_require__(21); + +var WeakMap = globalThis.WeakMap; + +module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap)); + + +/***/ }), +/* 53 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var shared = __webpack_require__(34); +var uid = __webpack_require__(40); + +var keys = shared('keys'); + +module.exports = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + + +/***/ }), +/* 54 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = {}; + + +/***/ }), +/* 55 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(38); +var ownKeys = __webpack_require__(56); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var definePropertyModule = __webpack_require__(44); + +module.exports = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + + +/***/ }), +/* 56 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var getOwnPropertyNamesModule = __webpack_require__(57); +var getOwnPropertySymbolsModule = __webpack_require__(66); +var anObject = __webpack_require__(46); + +var concat = uncurryThis([].concat); + +// all object keys, includes non-enumerable and symbols +module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys; +}; + + +/***/ }), +/* 57 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var internalObjectKeys = __webpack_require__(58); +var enumBugKeys = __webpack_require__(65); + +var hiddenKeys = enumBugKeys.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); +}; + + +/***/ }), +/* 58 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var hasOwn = __webpack_require__(38); +var toIndexedObject = __webpack_require__(12); +var indexOf = __webpack_require__(59).indexOf; +var hiddenKeys = __webpack_require__(54); + +var push = uncurryThis([].push); + +module.exports = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; +}; + + +/***/ }), +/* 59 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__(12); +var toAbsoluteIndex = __webpack_require__(60); +var lengthOfArrayLike = __webpack_require__(63); + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = lengthOfArrayLike(O); + if (length === 0) return !IS_INCLUDES && -1; + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +module.exports = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) +}; + + +/***/ }), +/* 60 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(61); + +var max = Math.max; +var min = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +module.exports = function (index, length) { + var integer = toIntegerOrInfinity(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); +}; + + +/***/ }), +/* 61 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var trunc = __webpack_require__(62); + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +module.exports = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + + +/***/ }), +/* 62 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ceil = Math.ceil; +var floor = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +module.exports = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); +}; + + +/***/ }), +/* 63 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toLength = __webpack_require__(64); + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +module.exports = function (obj) { + return toLength(obj.length); +}; + + +/***/ }), +/* 64 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(61); + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +module.exports = function (argument) { + var len = toIntegerOrInfinity(argument); + return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + + +/***/ }), +/* 65 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// IE8- don't enum bug keys +module.exports = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + + +/***/ }), +/* 66 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +exports.f = Object.getOwnPropertySymbols; + + +/***/ }), +/* 67 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var isCallable = __webpack_require__(21); + +var replacement = /#|\.prototype\./; + +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable(detection) ? fails(detection) + : !!detection; +}; + +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; + +module.exports = isForced; + + +/***/ }), +/* 68 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(69); + +var $String = String; + +module.exports = function (argument) { + if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); +}; + + +/***/ }), +/* 69 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(70); +var isCallable = __webpack_require__(21); +var classofRaw = __webpack_require__(15); +var wellKnownSymbol = __webpack_require__(33); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var $Object = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result; +}; + + +/***/ }), +/* 70 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; +// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation +test[TO_STRING_TAG] = 'z'; + +module.exports = String(test) === '[object z]'; + + +/***/ }), +/* 71 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* global ActiveXObject -- old IE, WSH */ +var anObject = __webpack_require__(46); +var definePropertiesModule = __webpack_require__(72); +var enumBugKeys = __webpack_require__(65); +var hiddenKeys = __webpack_require__(54); +var html = __webpack_require__(74); +var documentCreateElement = __webpack_require__(42); +var sharedKey = __webpack_require__(53); + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + var temp; + try { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + temp = activeXDocument.parentWindow.Object; + } catch (error) { + temp = NullProtoObjectViaSc32bit(); + } + // eslint-disable-next-line no-useless-assignment -- avoid memory leak + activeXDocument = null; + return temp; +}; + +// Attempt to obtain an Object constructor capable of creating +// null-prototype objects using 32-bit MSScriptControl. +// This approach only works in 32-bit environments where ScriptControl is available. +var sc32bit; + +// Function to retrieve Object constructor via 32-bit ScriptControl (typically provided by Microsoft) +var NullProtoObjectViaSc32bit = function () { + try { + sc32bit = new ActiveXObject('MSScriptControl.ScriptControl'); + sc32bit.Language = 'JScript'; + return sc32bit.Eval('Object'); + } catch (error) { + // Fallback to 64-bit alternative if 32-bit ScriptControl is unavailable + return NullProtoObjectViaSc64bit(); + } +}; + +// Reference for 64-bit ScriptControl instance +var sc64bit; + +// Function to retrieve the Object constructor via 64-bit ScriptControl (typically provided by third parties) +var NullProtoObjectViaSc64bit = function () { + try { + sc64bit = new ActiveXObject('ScriptControl'); + sc64bit.Language = 'JScript'; + return sc64bit.Eval('Object'); + } catch (error) { + // Throw explicit error if ScriptControl is not available in 64-bit environment + throw new Error('A compatible ScriptControl version is required to support null-prototype objects on 64-bit environments.'); + } +} + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys[IE_PROTO] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +// eslint-disable-next-line es/no-object-create -- safe +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); +}; + + +/***/ }), +/* 72 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(45); +var definePropertyModule = __webpack_require__(44); +var anObject = __webpack_require__(46); +var toIndexedObject = __webpack_require__(12); +var objectKeys = __webpack_require__(73); + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var props = toIndexedObject(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]); + return O; +}; + + +/***/ }), +/* 73 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var internalObjectKeys = __webpack_require__(58); +var enumBugKeys = __webpack_require__(65); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +module.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + + +/***/ }), +/* 74 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); + +module.exports = getBuiltIn('document', 'documentElement'); + + +/***/ }), +/* 75 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-object-getownpropertynames -- safe */ +var classof = __webpack_require__(15); +var toIndexedObject = __webpack_require__(12); +var $getOwnPropertyNames = __webpack_require__(57).f; +var arraySlice = __webpack_require__(76); + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice(windowNames); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +module.exports.f = function getOwnPropertyNames(it) { + return windowNames && classof(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject(it)); +}; + + +/***/ }), +/* 76 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +module.exports = uncurryThis([].slice); + + +/***/ }), +/* 77 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var makeBuiltIn = __webpack_require__(48); +var defineProperty = __webpack_require__(44); + +module.exports = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true }); + return defineProperty.f(target, name, descriptor); +}; + + +/***/ }), +/* 78 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); + +exports.f = wellKnownSymbol; + + +/***/ }), +/* 79 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var path = __webpack_require__(80); +var hasOwn = __webpack_require__(38); +var wrappedWellKnownSymbolModule = __webpack_require__(78); +var defineProperty = __webpack_require__(44).f; + +module.exports = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, { + value: wrappedWellKnownSymbolModule.f(NAME) + }); +}; + + +/***/ }), +/* 80 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +module.exports = globalThis; + + +/***/ }), +/* 81 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var getBuiltIn = __webpack_require__(23); +var wellKnownSymbol = __webpack_require__(33); +var defineBuiltIn = __webpack_require__(47); + +module.exports = function () { + var Symbol = getBuiltIn('Symbol'); + var SymbolPrototype = Symbol && Symbol.prototype; + var valueOf = SymbolPrototype && SymbolPrototype.valueOf; + var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); + + if (SymbolPrototype && !SymbolPrototype[TO_PRIMITIVE]) { + // `Symbol.prototype[@@toPrimitive]` method + // https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive + // eslint-disable-next-line no-unused-vars -- required for .length + defineBuiltIn(SymbolPrototype, TO_PRIMITIVE, function (hint) { + return call(valueOf, this); + }, { arity: 1 }); + } +}; + + +/***/ }), +/* 82 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineProperty = __webpack_require__(44).f; +var hasOwn = __webpack_require__(38); +var wellKnownSymbol = __webpack_require__(33); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +module.exports = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn(target, TO_STRING_TAG)) { + defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + + +/***/ }), +/* 83 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var IndexedObject = __webpack_require__(13); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var arraySpeciesCreate = __webpack_require__(86); +var createProperty = __webpack_require__(90); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that) { + var O = toObject($this); + var self = IndexedObject(O); + var length = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var index = 0; + var resIndex = 0; + var target = IS_MAP ? arraySpeciesCreate($this, length) : IS_FILTER || IS_FILTER_REJECT ? arraySpeciesCreate($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) createProperty(target, index, result); // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: createProperty(target, resIndex++, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: createProperty(target, resIndex++, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +module.exports = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) +}; + + +/***/ }), +/* 84 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(85); +var aCallable = __webpack_require__(30); +var NATIVE_BIND = __webpack_require__(9); + +var bind = uncurryThis(uncurryThis.bind); + +// optional / simple context binding +module.exports = function (fn, that) { + aCallable(fn); + return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + + +/***/ }), +/* 85 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classofRaw = __webpack_require__(15); +var uncurryThis = __webpack_require__(14); + +module.exports = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis(fn); +}; + + +/***/ }), +/* 86 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var arraySpeciesConstructor = __webpack_require__(87); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + + +/***/ }), +/* 87 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isArray = __webpack_require__(88); +var isConstructor = __webpack_require__(89); +var isObject = __webpack_require__(20); +var wellKnownSymbol = __webpack_require__(33); + +var SPECIES = wellKnownSymbol('species'); +var $Array = Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array : C; +}; + + +/***/ }), +/* 88 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(15); + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +module.exports = Array.isArray || function isArray(argument) { + return classof(argument) === 'Array'; +}; + + +/***/ }), +/* 89 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var isCallable = __webpack_require__(21); +var classof = __webpack_require__(69); +var getBuiltIn = __webpack_require__(23); +var inspectSource = __webpack_require__(50); + +var noop = function () { /* empty */ }; +var construct = getBuiltIn('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable(argument)) return false; + try { + construct(noop, [], argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable(argument)) return false; + switch (classof(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +module.exports = !construct || fails(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + + +/***/ }), +/* 90 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var definePropertyModule = __webpack_require__(44); +var createPropertyDescriptor = __webpack_require__(11); + +module.exports = function (object, key, value) { + if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value)); + else object[key] = value; +}; + + +/***/ }), +/* 91 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var hasOwn = __webpack_require__(38); +var toString = __webpack_require__(68); +var shared = __webpack_require__(34); +var NATIVE_SYMBOL_REGISTRY = __webpack_require__(92); + +var StringToSymbolRegistry = shared('string-to-symbol-registry'); +var SymbolToStringRegistry = shared('symbol-to-string-registry'); + +// `Symbol.for` method +// https://tc39.es/ecma262/#sec-symbol.for +$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, { + 'for': function (key) { + var string = toString(key); + if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; + var symbol = getBuiltIn('Symbol')(string); + StringToSymbolRegistry[string] = symbol; + SymbolToStringRegistry[symbol] = string; + return symbol; + } +}); + + +/***/ }), +/* 92 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_SYMBOL = __webpack_require__(26); + +/* eslint-disable es/no-symbol -- safe */ +module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor; + + +/***/ }), +/* 93 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var hasOwn = __webpack_require__(38); +var isSymbol = __webpack_require__(22); +var tryToString = __webpack_require__(31); +var shared = __webpack_require__(34); +var NATIVE_SYMBOL_REGISTRY = __webpack_require__(92); + +var SymbolToStringRegistry = shared('symbol-to-string-registry'); + +// `Symbol.keyFor` method +// https://tc39.es/ecma262/#sec-symbol.keyfor +$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, { + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) throw new TypeError(tryToString(sym) + ' is not a symbol'); + if (hasOwn(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym]; + } +}); + + +/***/ }), +/* 94 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var apply = __webpack_require__(95); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var isArray = __webpack_require__(88); +var isCallable = __webpack_require__(21); +var isRawJSON = __webpack_require__(96); +var isSymbol = __webpack_require__(22); +var classof = __webpack_require__(15); +var toString = __webpack_require__(68); +var arraySlice = __webpack_require__(76); +var parseJSONString = __webpack_require__(97); +var uid = __webpack_require__(40); +var NATIVE_SYMBOL = __webpack_require__(26); +var NATIVE_RAW_JSON = __webpack_require__(98); + +var $String = String; +var $stringify = getBuiltIn('JSON', 'stringify'); +var exec = uncurryThis(/./.exec); +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var replace = uncurryThis(''.replace); +var slice = uncurryThis(''.slice); +var push = uncurryThis([].push); +var numberToString = uncurryThis(1.1.toString); + +var surrogates = /[\uD800-\uDFFF]/g; +var leadingSurrogates = /^[\uD800-\uDBFF]$/; +var trailingSurrogates = /^[\uDC00-\uDFFF]$/; + +var MARK = uid(); +var MARK_LENGTH = MARK.length; + +var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails(function () { + var symbol = getBuiltIn('Symbol')('stringify detection'); + // MS Edge converts symbol values to JSON as {} + return $stringify([symbol]) !== '[null]' + // WebKit converts symbol values to JSON as null + || $stringify({ a: symbol }) !== '{}' + // V8 throws on boxed symbols + || $stringify(Object(symbol)) !== '{}'; +}); + +// https://github.com/tc39/proposal-well-formed-stringify +var ILL_FORMED_UNICODE = fails(function () { + return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"' + || $stringify('\uDEAD') !== '"\\udead"'; +}); + +var stringifyWithProperSymbolsConversion = WRONG_SYMBOLS_CONVERSION ? function (it, replacer) { + var args = arraySlice(arguments); + var $replacer = getReplacerFunction(replacer); + if (!isCallable($replacer) && (it === undefined || isSymbol(it))) return; // IE8 returns string on undefined + args[1] = function (key, value) { + // some old implementations (like WebKit) could pass numbers as keys + if (isCallable($replacer)) value = call($replacer, this, $String(key), value); + if (!isSymbol(value)) return value; + }; + return apply($stringify, null, args); +} : $stringify; + +var fixIllFormedJSON = function (match, offset, string) { + var prev = charAt(string, offset - 1); + var next = charAt(string, offset + 1); + if ( + (exec(leadingSurrogates, match) && !exec(trailingSurrogates, next)) || + (exec(trailingSurrogates, match) && !exec(leadingSurrogates, prev)) + ) { + return '\\u' + numberToString(charCodeAt(match, 0), 16); + } return match; +}; + +var getReplacerFunction = function (replacer) { + if (isCallable(replacer)) return replacer; + if (!isArray(replacer)) return; + var rawLength = replacer.length; + var keys = []; + for (var i = 0; i < rawLength; i++) { + var element = replacer[i]; + if (typeof element == 'string') push(keys, element); + else if (typeof element == 'number' || classof(element) === 'Number' || classof(element) === 'String') push(keys, toString(element)); + } + var keysLength = keys.length; + var root = true; + return function (key, value) { + if (root) { + root = false; + return value; + } + if (isArray(this)) return value; + for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value; + }; +}; + +// `JSON.stringify` method +// https://tc39.es/ecma262/#sec-json.stringify +// https://github.com/tc39/proposal-json-parse-with-source +if ($stringify) $({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE || !NATIVE_RAW_JSON }, { + stringify: function stringify(text, replacer, space) { + var replacerFunction = getReplacerFunction(replacer); + var rawStrings = []; + + var json = stringifyWithProperSymbolsConversion(text, function (key, value) { + // some old implementations (like WebKit) could pass numbers as keys + var v = isCallable(replacerFunction) ? call(replacerFunction, this, $String(key), value) : value; + return !NATIVE_RAW_JSON && isRawJSON(v) ? MARK + (push(rawStrings, v.rawJSON) - 1) : v; + }, space); + + if (typeof json != 'string') return json; + + if (ILL_FORMED_UNICODE) json = replace(json, surrogates, fixIllFormedJSON); + + if (NATIVE_RAW_JSON) return json; + + var result = ''; + var length = json.length; + + for (var i = 0; i < length; i++) { + var chr = charAt(json, i); + if (chr === '"') { + var end = parseJSONString(json, ++i).end - 1; + var string = slice(json, i, end); + result += slice(string, 0, MARK_LENGTH) === MARK + ? rawStrings[slice(string, MARK_LENGTH)] + : '"' + string + '"'; + i = end; + } else result += chr; + } + + return result; + } +}); + + +/***/ }), +/* 95 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_BIND = __webpack_require__(9); + +var FunctionPrototype = Function.prototype; +var apply = FunctionPrototype.apply; +var call = FunctionPrototype.call; + +// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe +module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () { + return call.apply(apply, arguments); +}); + + +/***/ }), +/* 96 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); +var getInternalState = __webpack_require__(51).get; + +module.exports = function isRawJSON(O) { + if (!isObject(O)) return false; + var state = getInternalState(O); + return !!state && state.type === 'RawJSON'; +}; + + +/***/ }), +/* 97 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var hasOwn = __webpack_require__(38); + +var $SyntaxError = SyntaxError; +var $parseInt = parseInt; +var fromCharCode = String.fromCharCode; +var at = uncurryThis(''.charAt); +var slice = uncurryThis(''.slice); +var exec = uncurryThis(/./.exec); + +var codePoints = { + '\\"': '"', + '\\\\': '\\', + '\\/': '/', + '\\b': '\b', + '\\f': '\f', + '\\n': '\n', + '\\r': '\r', + '\\t': '\t' +}; + +var IS_4_HEX_DIGITS = /^[\da-f]{4}$/i; +// eslint-disable-next-line regexp/no-control-character -- safe +var IS_C0_CONTROL_CODE = /^[\u0000-\u001F]$/; + +module.exports = function (source, i) { + var unterminated = true; + var value = ''; + while (i < source.length) { + var chr = at(source, i); + if (chr === '\\') { + var twoChars = slice(source, i, i + 2); + if (hasOwn(codePoints, twoChars)) { + value += codePoints[twoChars]; + i += 2; + } else if (twoChars === '\\u') { + i += 2; + var fourHexDigits = slice(source, i, i + 4); + if (!exec(IS_4_HEX_DIGITS, fourHexDigits)) throw new $SyntaxError('Bad Unicode escape at: ' + i); + value += fromCharCode($parseInt(fourHexDigits, 16)); + i += 4; + } else throw new $SyntaxError('Unknown escape sequence: "' + twoChars + '"'); + } else if (chr === '"') { + unterminated = false; + i++; + break; + } else { + if (exec(IS_C0_CONTROL_CODE, chr)) throw new $SyntaxError('Bad control character in string literal at: ' + i); + value += chr; + i++; + } + } + if (unterminated) throw new $SyntaxError('Unterminated string at: ' + i); + return { value: value, end: i }; +}; + + +/***/ }), +/* 98 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-json -- safe */ +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + var unsafeInt = '9007199254740993'; + // eslint-disable-next-line es/no-json-rawjson -- feature detection + var raw = JSON.rawJSON(unsafeInt); + // eslint-disable-next-line es/no-json-israwjson -- feature detection + return !JSON.isRawJSON(raw) || JSON.stringify(raw) !== unsafeInt; +}); + + +/***/ }), +/* 99 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var NATIVE_SYMBOL = __webpack_require__(26); +var fails = __webpack_require__(7); +var getOwnPropertySymbolsModule = __webpack_require__(66); +var toObject = __webpack_require__(39); + +// V8 ~ Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives +// https://bugs.chromium.org/p/v8/issues/detail?id=3443 +var FORCED = !NATIVE_SYMBOL || fails(function () { getOwnPropertySymbolsModule.f(1); }); + +// `Object.getOwnPropertySymbols` method +// https://tc39.es/ecma262/#sec-object.getownpropertysymbols +$({ target: 'Object', stat: true, forced: FORCED }, { + getOwnPropertySymbols: function getOwnPropertySymbols(it) { + var $getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return $getOwnPropertySymbols ? $getOwnPropertySymbols(toObject(it)) : []; + } +}); + + +/***/ }), +/* 100 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// `Symbol.prototype.description` getter +// https://tc39.es/ecma262/#sec-symbol.prototype.description + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var globalThis = __webpack_require__(4); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var hasOwn = __webpack_require__(38); +var isCallable = __webpack_require__(21); +var isPrototypeOf = __webpack_require__(24); +var toString = __webpack_require__(68); +var defineBuiltInAccessor = __webpack_require__(77); +var copyConstructorProperties = __webpack_require__(55); + +var NativeSymbol = globalThis.Symbol; +var SymbolPrototype = NativeSymbol && NativeSymbol.prototype; + +if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) || + // Safari 12 bug + NativeSymbol().description !== undefined +)) { + var EmptyStringDescriptionStore = {}; + // wrap Symbol constructor for correct work with undefined description + var SymbolWrapper = function Symbol() { + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]); + var result = isPrototypeOf(SymbolPrototype, this) + // eslint-disable-next-line sonarjs/inconsistent-function-call -- ok + ? new NativeSymbol(description) + // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' + : description === undefined ? NativeSymbol() : NativeSymbol(description); + if (description === '') EmptyStringDescriptionStore[result] = true; + return result; + }; + + copyConstructorProperties(SymbolWrapper, NativeSymbol); + // wrap Symbol.for for correct handling of empty string descriptions + var nativeFor = SymbolWrapper['for']; + SymbolWrapper['for'] = { 'for': function (key) { + var stringKey = toString(key); + var symbol = call(nativeFor, this, stringKey); + if (stringKey === '') EmptyStringDescriptionStore[symbol] = true; + return symbol; + } }['for']; + SymbolWrapper.prototype = SymbolPrototype; + SymbolPrototype.constructor = SymbolWrapper; + + var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)'; + var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf); + var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString); + var regexp = /^Symbol\((.*)\)[^)]+$/; + var replace = uncurryThis(''.replace); + var stringSlice = uncurryThis(''.slice); + + defineBuiltInAccessor(SymbolPrototype, 'description', { + configurable: true, + get: function description() { + var symbol = thisSymbolValue(this); + if (hasOwn(EmptyStringDescriptionStore, symbol)) return ''; + var string = symbolDescriptiveString(symbol); + var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1'); + return desc === '' ? undefined : desc; + } + }); + + $({ global: true, constructor: true, forced: true }, { + Symbol: SymbolWrapper + }); +} + + +/***/ }), +/* 101 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var defineWellKnownSymbol = __webpack_require__(79); +var defineProperty = __webpack_require__(44).f; +var getOwnPropertyDescriptor = __webpack_require__(5).f; + +var Symbol = globalThis.Symbol; + +// `Symbol.asyncDispose` well-known symbol +// https://github.com/tc39/proposal-async-explicit-resource-management +defineWellKnownSymbol('asyncDispose'); + +if (Symbol) { + var descriptor = getOwnPropertyDescriptor(Symbol, 'asyncDispose'); + // workaround of NodeJS 20.4 bug + // https://github.com/nodejs/node/issues/48699 + // and incorrect descriptor from some transpilers and userland helpers + if (descriptor.enumerable && descriptor.configurable && descriptor.writable) { + defineProperty(Symbol, 'asyncDispose', { value: descriptor.value, enumerable: false, configurable: false, writable: false }); + } +} + + +/***/ }), +/* 102 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.asyncIterator` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.asynciterator +defineWellKnownSymbol('asyncIterator'); + + +/***/ }), +/* 103 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var defineWellKnownSymbol = __webpack_require__(79); +var defineProperty = __webpack_require__(44).f; +var getOwnPropertyDescriptor = __webpack_require__(5).f; + +var Symbol = globalThis.Symbol; + +// `Symbol.dispose` well-known symbol +// https://github.com/tc39/proposal-explicit-resource-management +defineWellKnownSymbol('dispose'); + +if (Symbol) { + var descriptor = getOwnPropertyDescriptor(Symbol, 'dispose'); + // workaround of NodeJS 20.4 bug + // https://github.com/nodejs/node/issues/48699 + // and incorrect descriptor from some transpilers and userland helpers + if (descriptor.enumerable && descriptor.configurable && descriptor.writable) { + defineProperty(Symbol, 'dispose', { value: descriptor.value, enumerable: false, configurable: false, writable: false }); + } +} + + +/***/ }), +/* 104 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.hasInstance` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.hasinstance +defineWellKnownSymbol('hasInstance'); + + +/***/ }), +/* 105 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.isConcatSpreadable` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.isconcatspreadable +defineWellKnownSymbol('isConcatSpreadable'); + + +/***/ }), +/* 106 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.iterator` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.iterator +defineWellKnownSymbol('iterator'); + + +/***/ }), +/* 107 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.match` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.match +defineWellKnownSymbol('match'); + + +/***/ }), +/* 108 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.matchAll` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.matchall +defineWellKnownSymbol('matchAll'); + + +/***/ }), +/* 109 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.replace` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.replace +defineWellKnownSymbol('replace'); + + +/***/ }), +/* 110 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.search` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.search +defineWellKnownSymbol('search'); + + +/***/ }), +/* 111 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.species` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.species +defineWellKnownSymbol('species'); + + +/***/ }), +/* 112 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.split` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.split +defineWellKnownSymbol('split'); + + +/***/ }), +/* 113 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); +var defineSymbolToPrimitive = __webpack_require__(81); + +// `Symbol.toPrimitive` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.toprimitive +defineWellKnownSymbol('toPrimitive'); + +// `Symbol.prototype[@@toPrimitive]` method +// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive +defineSymbolToPrimitive(); + + +/***/ }), +/* 114 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var defineWellKnownSymbol = __webpack_require__(79); +var setToStringTag = __webpack_require__(82); + +// `Symbol.toStringTag` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.tostringtag +defineWellKnownSymbol('toStringTag'); + +// `Symbol.prototype[@@toStringTag]` property +// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag +setToStringTag(getBuiltIn('Symbol'), 'Symbol'); + + +/***/ }), +/* 115 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.unscopables` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.unscopables +defineWellKnownSymbol('unscopables'); + + +/***/ }), +/* 116 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable no-unused-vars -- required for functions `.length` */ +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var apply = __webpack_require__(95); +var wrapErrorConstructorWithCause = __webpack_require__(117); + +var WEB_ASSEMBLY = 'WebAssembly'; +var WebAssembly = globalThis[WEB_ASSEMBLY]; + +// eslint-disable-next-line es/no-error-cause -- feature detection +var FORCED = new Error('e', { cause: 7 }).cause !== 7; + +var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) { + var O = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED); + $({ global: true, constructor: true, arity: 1, forced: FORCED }, O); +}; + +var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) { + if (WebAssembly && WebAssembly[ERROR_NAME]) { + var O = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED); + $({ target: WEB_ASSEMBLY, stat: true, constructor: true, arity: 1, forced: FORCED }, O); + } +}; + +// https://tc39.es/ecma262/#sec-nativeerror +exportGlobalErrorCauseWrapper('Error', function (init) { + return function Error(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('EvalError', function (init) { + return function EvalError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('RangeError', function (init) { + return function RangeError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('ReferenceError', function (init) { + return function ReferenceError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('SyntaxError', function (init) { + return function SyntaxError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('TypeError', function (init) { + return function TypeError(message) { return apply(init, this, arguments); }; +}); +exportGlobalErrorCauseWrapper('URIError', function (init) { + return function URIError(message) { return apply(init, this, arguments); }; +}); +exportWebAssemblyErrorCauseWrapper('CompileError', function (init) { + return function CompileError(message) { return apply(init, this, arguments); }; +}); +exportWebAssemblyErrorCauseWrapper('LinkError', function (init) { + return function LinkError(message) { return apply(init, this, arguments); }; +}); +exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) { + return function RuntimeError(message) { return apply(init, this, arguments); }; +}); + + +/***/ }), +/* 117 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var hasOwn = __webpack_require__(38); +var createNonEnumerableProperty = __webpack_require__(43); +var isPrototypeOf = __webpack_require__(24); +var setPrototypeOf = __webpack_require__(118); +var copyConstructorProperties = __webpack_require__(55); +var proxyAccessor = __webpack_require__(122); +var inheritIfRequired = __webpack_require__(123); +var normalizeStringArgument = __webpack_require__(124); +var installErrorCause = __webpack_require__(125); +var installErrorStack = __webpack_require__(126); +var DESCRIPTORS = __webpack_require__(6); +var IS_PURE = __webpack_require__(36); + +module.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) { + var STACK_TRACE_LIMIT = 'stackTraceLimit'; + var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1; + var path = FULL_NAME.split('.'); + var ERROR_NAME = path[path.length - 1]; + var OriginalError = getBuiltIn.apply(null, path); + + if (!OriginalError) return; + + var OriginalErrorPrototype = OriginalError.prototype; + + // V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006 + if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause; + + if (!FORCED) return OriginalError; + + var BaseError = getBuiltIn('Error'); + + var WrappedError = wrapper(function (a, b) { + var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined); + var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError(); + if (message !== undefined) createNonEnumerableProperty(result, 'message', message); + installErrorStack(result, WrappedError, result.stack, 2); + if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError); + if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]); + return result; + }); + + WrappedError.prototype = OriginalErrorPrototype; + + if (ERROR_NAME !== 'Error') { + if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError); + else copyConstructorProperties(WrappedError, BaseError, { name: true }); + } else if (DESCRIPTORS && STACK_TRACE_LIMIT in OriginalError) { + proxyAccessor(WrappedError, OriginalError, STACK_TRACE_LIMIT); + proxyAccessor(WrappedError, OriginalError, 'prepareStackTrace'); + } + + copyConstructorProperties(WrappedError, OriginalError); + + if (!IS_PURE) try { + // Safari 13- bug: WebAssembly errors does not have a proper `.name` + if (OriginalErrorPrototype.name !== ERROR_NAME) { + createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME); + } + OriginalErrorPrototype.constructor = WrappedError; + } catch (error) { /* empty */ } + + return WrappedError; +}; + + +/***/ }), +/* 118 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = __webpack_require__(119); +var isObject = __webpack_require__(20); +var requireObjectCoercible = __webpack_require__(16); +var aPossiblePrototype = __webpack_require__(120); + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + requireObjectCoercible(O); + aPossiblePrototype(proto); + if (!isObject(O)) return O; + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + + +/***/ }), +/* 119 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); + +module.exports = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + + +/***/ }), +/* 120 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isPossiblePrototype = __webpack_require__(121); + +var $String = String; +var $TypeError = TypeError; + +module.exports = function (argument) { + if (isPossiblePrototype(argument)) return argument; + throw new $TypeError("Can't set " + $String(argument) + ' as a prototype'); +}; + + +/***/ }), +/* 121 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); + +module.exports = function (argument) { + return isObject(argument) || argument === null; +}; + + +/***/ }), +/* 122 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineProperty = __webpack_require__(44).f; + +module.exports = function (Target, Source, key) { + key in Target || defineProperty(Target, key, { + configurable: true, + get: function () { return Source[key]; }, + set: function (it) { Source[key] = it; } + }); +}; + + +/***/ }), +/* 123 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var setPrototypeOf = __webpack_require__(118); + +// makes subclassing work correct for wrapped built-ins +module.exports = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + + +/***/ }), +/* 124 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toString = __webpack_require__(68); + +module.exports = function (argument, $default) { + return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument); +}; + + +/***/ }), +/* 125 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); +var createNonEnumerableProperty = __webpack_require__(43); + +// `InstallErrorCause` abstract operation +// https://tc39.es/ecma262/#sec-installerrorcause +module.exports = function (O, options) { + if (isObject(options) && 'cause' in options) { + createNonEnumerableProperty(O, 'cause', options.cause); + } +}; + + +/***/ }), +/* 126 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createNonEnumerableProperty = __webpack_require__(43); +var clearErrorStack = __webpack_require__(127); +var ERROR_STACK_INSTALLABLE = __webpack_require__(128); + +// non-standard V8 +// eslint-disable-next-line es/no-nonstandard-error-properties -- safe +var captureStackTrace = Error.captureStackTrace; + +module.exports = function (error, C, stack, dropEntries) { + if (ERROR_STACK_INSTALLABLE) { + if (captureStackTrace) captureStackTrace(error, C); + else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries)); + } +}; + + +/***/ }), +/* 127 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +var $Error = Error; +var replace = uncurryThis(''.replace); + +var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd'); +// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe +var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/; +var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST); + +module.exports = function (stack, dropEntries) { + if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) { + while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, ''); + } return stack; +}; + + +/***/ }), +/* 128 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var createPropertyDescriptor = __webpack_require__(11); + +module.exports = !fails(function () { + var error = new Error('a'); + if (!('stack' in error)) return true; + // eslint-disable-next-line es/no-object-defineproperty -- safe + Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7)); + return error.stack !== 7; +}); + + +/***/ }), +/* 129 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var isObject = __webpack_require__(20); +var classof = __webpack_require__(69); +var fails = __webpack_require__(7); + +var ERROR = 'Error'; +var DOM_EXCEPTION = 'DOMException'; +// eslint-disable-next-line es/no-object-setprototypeof, no-proto -- safe +var PROTOTYPE_SETTING_AVAILABLE = Object.setPrototypeOf || {}.__proto__; + +var DOMException = getBuiltIn(DOM_EXCEPTION); +var $Error = Error; +// eslint-disable-next-line es/no-error-iserror -- safe +var $isError = $Error.isError; + +var FORCED = !$isError || !PROTOTYPE_SETTING_AVAILABLE || fails(function () { + // Bun, isNativeError-based implementations, some buggy structuredClone-based implementations, etc. + // https://github.com/oven-sh/bun/issues/15821 + return (DOMException && !$isError(new DOMException(DOM_EXCEPTION))) || + // structuredClone-based implementations + // eslint-disable-next-line es/no-error-cause -- detection + !$isError(new $Error(ERROR, { cause: function () { /* empty */ } })) || + // instanceof-based and FF Error#stack-based implementations + $isError(getBuiltIn('Object', 'create')($Error.prototype)); +}); + +// `Error.isError` method +// https://tc39.es/ecma262/#sec-error.iserror +$({ target: 'Error', stat: true, sham: true, forced: FORCED }, { + isError: function isError(arg) { + if (!isObject(arg)) return false; + var tag = classof(arg); + return tag === ERROR || tag === DOM_EXCEPTION; + } +}); + + +/***/ }), +/* 130 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineBuiltIn = __webpack_require__(47); +var errorToString = __webpack_require__(131); + +var ErrorPrototype = Error.prototype; + +// `Error.prototype.toString` method fix +// https://tc39.es/ecma262/#sec-error.prototype.tostring +if (ErrorPrototype.toString !== errorToString) { + defineBuiltIn(ErrorPrototype, 'toString', errorToString); +} + + +/***/ }), +/* 131 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var anObject = __webpack_require__(46); +var normalizeStringArgument = __webpack_require__(124); + +var nativeErrorToString = Error.prototype.toString; + +var INCORRECT_TO_STRING = fails(function () { + if (DESCRIPTORS) { + // Chrome 32- incorrectly call accessor + // eslint-disable-next-line es/no-object-create, es/no-object-defineproperty -- safe + var object = Object.create(Object.defineProperty({}, 'name', { get: function () { + return this === object; + } })); + if (nativeErrorToString.call(object) !== 'true') return true; + } + // FF10- does not properly handle non-strings + return nativeErrorToString.call({ message: 1, name: 2 }) !== '2: 1' + // IE8 does not properly handle defaults + || nativeErrorToString.call({}) !== 'Error'; +}); + +module.exports = INCORRECT_TO_STRING ? function toString() { + var O = anObject(this); + var name = normalizeStringArgument(O.name, 'Error'); + var message = normalizeStringArgument(O.message); + return !name ? message : !message ? name : name + ': ' + message; +} : nativeErrorToString; + + +/***/ }), +/* 132 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(133); + + +/***/ }), +/* 133 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isPrototypeOf = __webpack_require__(24); +var getPrototypeOf = __webpack_require__(134); +var setPrototypeOf = __webpack_require__(118); +var copyConstructorProperties = __webpack_require__(55); +var create = __webpack_require__(71); +var createNonEnumerableProperty = __webpack_require__(43); +var createPropertyDescriptor = __webpack_require__(11); +var installErrorCause = __webpack_require__(125); +var installErrorStack = __webpack_require__(126); +var iterate = __webpack_require__(136); +var normalizeStringArgument = __webpack_require__(124); +var wellKnownSymbol = __webpack_require__(33); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var $Error = Error; +var push = [].push; + +var $AggregateError = function AggregateError(errors, message /* , options */) { + var isInstance = isPrototypeOf(AggregateErrorPrototype, this); + var that; + if (setPrototypeOf) { + that = setPrototypeOf(new $Error(), isInstance ? getPrototypeOf(this) : AggregateErrorPrototype); + } else { + that = isInstance ? this : create(AggregateErrorPrototype); + createNonEnumerableProperty(that, TO_STRING_TAG, 'Error'); + } + if (message !== undefined) createNonEnumerableProperty(that, 'message', normalizeStringArgument(message)); + installErrorStack(that, $AggregateError, that.stack, 1); + if (arguments.length > 2) installErrorCause(that, arguments[2]); + var errorsArray = []; + iterate(errors, push, { that: errorsArray }); + createNonEnumerableProperty(that, 'errors', errorsArray); + return that; +}; + +if (setPrototypeOf) setPrototypeOf($AggregateError, $Error); +else copyConstructorProperties($AggregateError, $Error, { name: true }); + +var AggregateErrorPrototype = $AggregateError.prototype = create($Error.prototype, { + constructor: createPropertyDescriptor(1, $AggregateError), + message: createPropertyDescriptor(1, ''), + name: createPropertyDescriptor(1, 'AggregateError') +}); + +// `AggregateError` constructor +// https://tc39.es/ecma262/#sec-aggregate-error-constructor +$({ global: true, constructor: true, arity: 2 }, { + AggregateError: $AggregateError +}); + + +/***/ }), +/* 134 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(38); +var isCallable = __webpack_require__(21); +var toObject = __webpack_require__(39); +var sharedKey = __webpack_require__(53); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(135); + +var IE_PROTO = sharedKey('IE_PROTO'); +var $Object = Object; +var ObjectPrototype = $Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +// eslint-disable-next-line es/no-object-getprototypeof -- safe +module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject(O); + if (hasOwn(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; +}; + + +/***/ }), +/* 135 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + + +/***/ }), +/* 136 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var tryToString = __webpack_require__(31); +var isArrayIteratorMethod = __webpack_require__(137); +var lengthOfArrayLike = __webpack_require__(63); +var isPrototypeOf = __webpack_require__(24); +var getIterator = __webpack_require__(139); +var getIteratorMethod = __webpack_require__(140); +var iteratorClose = __webpack_require__(141); + +var $TypeError = TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +module.exports = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + var $iterator = iterator; + iterator = undefined; + if ($iterator) iteratorClose($iterator, 'normal'); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call(next, iterator)).done) { + // `IteratorValue` errors should propagate without closing the iterator + var value = step.value; + try { + result = callFn(value); + } catch (error) { + if (iterator) iteratorClose(iterator, 'throw', error); + else throw error; + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + + +/***/ }), +/* 137 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); +var Iterators = __webpack_require__(138); + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + + +/***/ }), +/* 138 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = {}; + + +/***/ }), +/* 139 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var tryToString = __webpack_require__(31); +var getIteratorMethod = __webpack_require__(140); + +var $TypeError = TypeError; + +module.exports = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator; + if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument)); + throw new $TypeError(tryToString(argument) + ' is not iterable'); +}; + + +/***/ }), +/* 140 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(69); +var getMethod = __webpack_require__(29); +var isNullOrUndefined = __webpack_require__(17); +var Iterators = __webpack_require__(138); +var wellKnownSymbol = __webpack_require__(33); + +var ITERATOR = wellKnownSymbol('iterator'); + +module.exports = function (it) { + if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR) + || getMethod(it, '@@iterator') + || Iterators[classof(it)]; +}; + + +/***/ }), +/* 141 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getMethod = __webpack_require__(29); + +module.exports = function (iterator, kind, value) { + var innerResult, innerError; + anObject(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject(innerResult); + return value; +}; + + +/***/ }), +/* 142 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var apply = __webpack_require__(95); +var fails = __webpack_require__(7); +var wrapErrorConstructorWithCause = __webpack_require__(117); + +var AGGREGATE_ERROR = 'AggregateError'; +var $AggregateError = getBuiltIn(AGGREGATE_ERROR); + +var FORCED = !fails(function () { + return $AggregateError([1]).errors[0] !== 1; +}) && fails(function () { + return $AggregateError([1], AGGREGATE_ERROR, { cause: 7 }).cause !== 7; +}); + +// https://tc39.es/ecma262/#sec-aggregate-error +$({ global: true, constructor: true, arity: 2, forced: FORCED }, { + AggregateError: wrapErrorConstructorWithCause(AGGREGATE_ERROR, function (init) { + // eslint-disable-next-line no-unused-vars -- required for functions `.length` + return function AggregateError(errors, message) { return apply(init, this, arguments); }; + }, FORCED, true) +}); + + +/***/ }), +/* 143 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var isPrototypeOf = __webpack_require__(24); +var getPrototypeOf = __webpack_require__(134); +var setPrototypeOf = __webpack_require__(118); +var copyConstructorProperties = __webpack_require__(55); +var create = __webpack_require__(71); +var createNonEnumerableProperty = __webpack_require__(43); +var createPropertyDescriptor = __webpack_require__(11); +var installErrorStack = __webpack_require__(126); +var normalizeStringArgument = __webpack_require__(124); +var wellKnownSymbol = __webpack_require__(33); +var fails = __webpack_require__(7); +var IS_PURE = __webpack_require__(36); + +var NativeSuppressedError = globalThis.SuppressedError; +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var $Error = Error; + +// https://github.com/oven-sh/bun/issues/9282 +var WRONG_ARITY = !!NativeSuppressedError && NativeSuppressedError.length !== 3; + +// https://github.com/oven-sh/bun/issues/9283 +var EXTRA_ARGS_SUPPORT = !!NativeSuppressedError && fails(function () { + return new NativeSuppressedError(1, 2, 3, { cause: 4 }).cause === 4; +}); + +var PATCH = WRONG_ARITY || EXTRA_ARGS_SUPPORT; + +var $SuppressedError = function SuppressedError(error, suppressed, message) { + var isInstance = isPrototypeOf(SuppressedErrorPrototype, this); + var that; + if (setPrototypeOf) { + that = PATCH && (!isInstance || getPrototypeOf(this) === SuppressedErrorPrototype) + ? new NativeSuppressedError() + : setPrototypeOf(new $Error(), isInstance ? getPrototypeOf(this) : SuppressedErrorPrototype); + } else { + that = isInstance ? this : create(SuppressedErrorPrototype); + createNonEnumerableProperty(that, TO_STRING_TAG, 'Error'); + } + if (message !== undefined) createNonEnumerableProperty(that, 'message', normalizeStringArgument(message)); + installErrorStack(that, $SuppressedError, that.stack, 1); + createNonEnumerableProperty(that, 'error', error); + createNonEnumerableProperty(that, 'suppressed', suppressed); + return that; +}; + +if (setPrototypeOf) setPrototypeOf($SuppressedError, $Error); +else copyConstructorProperties($SuppressedError, $Error, { name: true }); + +var SuppressedErrorPrototype = $SuppressedError.prototype = PATCH ? NativeSuppressedError.prototype : create($Error.prototype, { + constructor: createPropertyDescriptor(1, $SuppressedError), + message: createPropertyDescriptor(1, ''), + name: createPropertyDescriptor(1, 'SuppressedError') +}); + +if (PATCH && !IS_PURE) SuppressedErrorPrototype.constructor = $SuppressedError; + +// `SuppressedError` constructor +// https://github.com/tc39/proposal-explicit-resource-management +$({ global: true, constructor: true, arity: 3, forced: PATCH }, { + SuppressedError: $SuppressedError +}); + + +/***/ }), +/* 144 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var toIntegerOrInfinity = __webpack_require__(61); +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.at` method +// https://tc39.es/ecma262/#sec-array.prototype.at +$({ target: 'Array', proto: true }, { + at: function at(index) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + var relativeIndex = toIntegerOrInfinity(index); + var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex; + return (k < 0 || k >= len) ? undefined : O[k]; + } +}); + +addToUnscopables('at'); + + +/***/ }), +/* 145 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); +var create = __webpack_require__(71); +var defineProperty = __webpack_require__(44).f; + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +module.exports = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + + +/***/ }), +/* 146 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var isArray = __webpack_require__(88); +var isObject = __webpack_require__(20); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var doesNotExceedSafeInteger = __webpack_require__(147); +var createProperty = __webpack_require__(90); +var setArrayLength = __webpack_require__(148); +var arraySpeciesCreate = __webpack_require__(86); +var arrayMethodHasSpeciesSupport = __webpack_require__(149); +var wellKnownSymbol = __webpack_require__(33); +var V8_VERSION = __webpack_require__(27); + +var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); + +// We can't use this feature detection in V8 since it causes +// deoptimization and serious performance degradation +// https://github.com/zloirock/core-js/issues/679 +var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); + +var isConcatSpreadable = function (O) { + if (!isObject(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; + +var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat'); + +// `Array.prototype.concat` method +// https://tc39.es/ecma262/#sec-array.prototype.concat +// with adding support of @@isConcatSpreadable and @@species +$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty(A, n++, E); + } + } + setArrayLength(A, n); + return A; + } +}); + + +/***/ }), +/* 147 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $TypeError = TypeError; +var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + +module.exports = function (it) { + if (it > MAX_SAFE_INTEGER) throw new $TypeError('Maximum allowed index exceeded'); + return it; +}; + + +/***/ }), +/* 148 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var isArray = __webpack_require__(88); + +var $TypeError = TypeError; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Safari < 13 does not throw an error in this case +var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () { + // makes no sense without proper strict mode support + if (this !== undefined) return true; + try { + // eslint-disable-next-line es/no-object-defineproperty -- safe + Object.defineProperty([], 'length', { writable: false }).length = 1; + } catch (error) { + return error instanceof TypeError; + } +}(); + +module.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) { + if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) { + throw new $TypeError('Cannot set read only .length'); + } return O.length = length; +} : function (O, length) { + return O.length = length; +}; + + +/***/ }), +/* 149 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var wellKnownSymbol = __webpack_require__(33); +var V8_VERSION = __webpack_require__(27); + +var SPECIES = wellKnownSymbol('species'); + +module.exports = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION >= 51 || !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + + +/***/ }), +/* 150 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var copyWithin = __webpack_require__(151); +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.copyWithin` method +// https://tc39.es/ecma262/#sec-array.prototype.copywithin +$({ target: 'Array', proto: true }, { + copyWithin: copyWithin +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('copyWithin'); + + +/***/ }), +/* 151 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toObject = __webpack_require__(39); +var toAbsoluteIndex = __webpack_require__(60); +var lengthOfArrayLike = __webpack_require__(63); +var deletePropertyOrThrow = __webpack_require__(152); + +var min = Math.min; + +// `Array.prototype.copyWithin` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.copywithin +// eslint-disable-next-line es/no-array-prototype-copywithin -- safe +module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + var to = toAbsoluteIndex(target, len); + var from = toAbsoluteIndex(start, len); + var end = arguments.length > 2 ? arguments[2] : undefined; + var count = min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to); + var inc = 1; + if (from < to && to < from + count) { + inc = -1; + from += count - 1; + to += count - 1; + } + while (count-- > 0) { + if (from in O) O[to] = O[from]; + else deletePropertyOrThrow(O, to); + to += inc; + from += inc; + } return O; +}; + + +/***/ }), +/* 152 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var tryToString = __webpack_require__(31); + +var $TypeError = TypeError; + +module.exports = function (O, P) { + if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O)); +}; + + +/***/ }), +/* 153 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $every = __webpack_require__(83).every; +var arrayMethodIsStrict = __webpack_require__(154); + +var STRICT_METHOD = arrayMethodIsStrict('every'); + +// `Array.prototype.every` method +// https://tc39.es/ecma262/#sec-array.prototype.every +$({ target: 'Array', proto: true, forced: !STRICT_METHOD }, { + every: function every(callbackfn /* , thisArg */) { + return $every(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 154 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +module.exports = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); +}; + + +/***/ }), +/* 155 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fill = __webpack_require__(156); +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.fill` method +// https://tc39.es/ecma262/#sec-array.prototype.fill +$({ target: 'Array', proto: true }, { + fill: fill +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('fill'); + + +/***/ }), +/* 156 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toObject = __webpack_require__(39); +var toAbsoluteIndex = __webpack_require__(60); +var lengthOfArrayLike = __webpack_require__(63); + +// `Array.prototype.fill` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.fill +module.exports = function fill(value /* , start = 0, end = @length */) { + var O = toObject(this); + var length = lengthOfArrayLike(O); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + while (endPos > index) O[index++] = value; + return O; +}; + + +/***/ }), +/* 157 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $filter = __webpack_require__(83).filter; +var arrayMethodHasSpeciesSupport = __webpack_require__(149); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); + +// `Array.prototype.filter` method +// https://tc39.es/ecma262/#sec-array.prototype.filter +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 158 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $find = __webpack_require__(83).find; +var addToUnscopables = __webpack_require__(145); + +var FIND = 'find'; +var SKIPS_HOLES = true; + +// Shouldn't skip holes +// eslint-disable-next-line es/no-array-prototype-find -- testing +if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; }); + +// `Array.prototype.find` method +// https://tc39.es/ecma262/#sec-array.prototype.find +$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { + find: function find(callbackfn /* , that = undefined */) { + return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND); + + +/***/ }), +/* 159 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $findIndex = __webpack_require__(83).findIndex; +var addToUnscopables = __webpack_require__(145); + +var FIND_INDEX = 'findIndex'; +var SKIPS_HOLES = true; + +// Shouldn't skip holes +// eslint-disable-next-line es/no-array-prototype-findindex -- testing +if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; }); + +// `Array.prototype.findIndex` method +// https://tc39.es/ecma262/#sec-array.prototype.findindex +$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { + findIndex: function findIndex(callbackfn /* , that = undefined */) { + return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND_INDEX); + + +/***/ }), +/* 160 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $findLast = __webpack_require__(161).findLast; +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.findLast` method +// https://tc39.es/ecma262/#sec-array.prototype.findlast +$({ target: 'Array', proto: true }, { + findLast: function findLast(callbackfn /* , that = undefined */) { + return $findLast(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +addToUnscopables('findLast'); + + +/***/ }), +/* 161 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var IndexedObject = __webpack_require__(13); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); + +// `Array.prototype.{ findLast, findLastIndex }` methods implementation +var createMethod = function (TYPE) { + var IS_FIND_LAST_INDEX = TYPE === 1; + return function ($this, callbackfn, that) { + var O = toObject($this); + var self = IndexedObject(O); + var index = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var value, result; + while (index-- > 0) { + value = self[index]; + result = boundFunction(value, index, O); + if (result) switch (TYPE) { + case 0: return value; // findLast + case 1: return index; // findLastIndex + } + } + return IS_FIND_LAST_INDEX ? -1 : undefined; + }; +}; + +module.exports = { + // `Array.prototype.findLast` method + // https://github.com/tc39/proposal-array-find-from-last + findLast: createMethod(0), + // `Array.prototype.findLastIndex` method + // https://github.com/tc39/proposal-array-find-from-last + findLastIndex: createMethod(1) +}; + + +/***/ }), +/* 162 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $findLastIndex = __webpack_require__(161).findLastIndex; +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.findLastIndex` method +// https://tc39.es/ecma262/#sec-array.prototype.findlastindex +$({ target: 'Array', proto: true }, { + findLastIndex: function findLastIndex(callbackfn /* , that = undefined */) { + return $findLastIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +addToUnscopables('findLastIndex'); + + +/***/ }), +/* 163 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var flattenIntoArray = __webpack_require__(164); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var toIntegerOrInfinity = __webpack_require__(61); +var arraySpeciesCreate = __webpack_require__(86); + +// `Array.prototype.flat` method +// https://tc39.es/ecma262/#sec-array.prototype.flat +$({ target: 'Array', proto: true }, { + flat: function flat(/* depthArg = 1 */) { + var depthArg = arguments.length ? arguments[0] : undefined; + var O = toObject(this); + var sourceLen = lengthOfArrayLike(O); + var depthNum = depthArg === undefined ? 1 : toIntegerOrInfinity(depthArg); + var A = arraySpeciesCreate(O, 0); + flattenIntoArray(A, O, O, sourceLen, 0, depthNum); + return A; + } +}); + + +/***/ }), +/* 164 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isArray = __webpack_require__(88); +var lengthOfArrayLike = __webpack_require__(63); +var doesNotExceedSafeInteger = __webpack_require__(147); +var bind = __webpack_require__(84); +var createProperty = __webpack_require__(90); + +// `FlattenIntoArray` abstract operation +// https://tc39.es/ecma262/#sec-flattenintoarray +var flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) { + var targetIndex = start; + var sourceIndex = 0; + var mapFn = mapper ? bind(mapper, thisArg) : false; + var element, elementLen; + + while (sourceIndex < sourceLen) { + if (sourceIndex in source) { + element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex]; + + if (depth > 0 && isArray(element)) { + elementLen = lengthOfArrayLike(element); + targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1; + } else { + doesNotExceedSafeInteger(targetIndex + 1); + createProperty(target, targetIndex, element); + } + + targetIndex++; + } + sourceIndex++; + } + return targetIndex; +}; + +module.exports = flattenIntoArray; + + +/***/ }), +/* 165 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var flattenIntoArray = __webpack_require__(164); +var aCallable = __webpack_require__(30); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var arraySpeciesCreate = __webpack_require__(86); + +// `Array.prototype.flatMap` method +// https://tc39.es/ecma262/#sec-array.prototype.flatmap +$({ target: 'Array', proto: true }, { + flatMap: function flatMap(callbackfn /* , thisArg */) { + var O = toObject(this); + var sourceLen = lengthOfArrayLike(O); + var A; + aCallable(callbackfn); + A = arraySpeciesCreate(O, 0); + flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return A; + } +}); + + +/***/ }), +/* 166 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var forEach = __webpack_require__(167); + +// `Array.prototype.forEach` method +// https://tc39.es/ecma262/#sec-array.prototype.foreach +// eslint-disable-next-line es/no-array-prototype-foreach -- safe +$({ target: 'Array', proto: true, forced: [].forEach !== forEach }, { + forEach: forEach +}); + + +/***/ }), +/* 167 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $forEach = __webpack_require__(83).forEach; +var arrayMethodIsStrict = __webpack_require__(154); + +var STRICT_METHOD = arrayMethodIsStrict('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.foreach +module.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +// eslint-disable-next-line es/no-array-prototype-foreach -- safe +} : [].forEach; + + +/***/ }), +/* 168 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var from = __webpack_require__(169); +var checkCorrectnessOfIteration = __webpack_require__(171); + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.es/ecma262/#sec-array.from +$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from +}); + + +/***/ }), +/* 169 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var call = __webpack_require__(8); +var toObject = __webpack_require__(39); +var callWithSafeIterationClosing = __webpack_require__(170); +var isArrayIteratorMethod = __webpack_require__(137); +var isConstructor = __webpack_require__(89); +var lengthOfArrayLike = __webpack_require__(63); +var createProperty = __webpack_require__(90); +var setArrayLength = __webpack_require__(148); +var getIterator = __webpack_require__(139); +var getIteratorMethod = __webpack_require__(140); +var iteratorClose = __webpack_require__(141); + +var $Array = Array; + +// `Array.from` method implementation +// https://tc39.es/ecma262/#sec-array.from +module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var O = toObject(arrayLike); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) { + result = IS_CONSTRUCTOR ? new this() : []; + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + for (;!(step = call(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + try { + createProperty(result, index, value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + } + } else { + length = lengthOfArrayLike(O); + result = IS_CONSTRUCTOR ? new this(length) : $Array(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + setArrayLength(result, index); + return result; +}; + + +/***/ }), +/* 170 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); +var iteratorClose = __webpack_require__(141); + +// call something on iterator step with safe closing on error +module.exports = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } +}; + + +/***/ }), +/* 171 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); + +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +module.exports = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + + +/***/ }), +/* 172 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $includes = __webpack_require__(59).includes; +var fails = __webpack_require__(7); +var addToUnscopables = __webpack_require__(145); + +// FF99+ bug +var BROKEN_ON_SPARSE = fails(function () { + // eslint-disable-next-line es/no-array-prototype-includes -- detection + return !Array(1).includes(); +}); + +// Safari 26.4- bug +var BROKEN_ON_SPARSE_WITH_FROM_INDEX = fails(function () { + // eslint-disable-next-line no-sparse-arrays, es/no-array-prototype-includes -- detection + return [, 1].includes(undefined, 1); +}); + +// `Array.prototype.includes` method +// https://tc39.es/ecma262/#sec-array.prototype.includes +$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE || BROKEN_ON_SPARSE_WITH_FROM_INDEX }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('includes'); + + +/***/ }), +/* 173 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-array-prototype-indexof -- required for testing */ +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(85); +var $indexOf = __webpack_require__(59).indexOf; +var arrayMethodIsStrict = __webpack_require__(154); + +var nativeIndexOf = uncurryThis([].indexOf); + +var NEGATIVE_ZERO = !!nativeIndexOf && 1 / nativeIndexOf([1], 1, -0) < 0; +var FORCED = NEGATIVE_ZERO || !arrayMethodIsStrict('indexOf'); + +// `Array.prototype.indexOf` method +// https://tc39.es/ecma262/#sec-array.prototype.indexof +$({ target: 'Array', proto: true, forced: FORCED }, { + indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { + var fromIndex = arguments.length > 1 ? arguments[1] : undefined; + return NEGATIVE_ZERO + // convert -0 to +0 + ? nativeIndexOf(this, searchElement, fromIndex) || 0 + : $indexOf(this, searchElement, fromIndex); + } +}); + + +/***/ }), +/* 174 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isArray = __webpack_require__(88); + +// `Array.isArray` method +// https://tc39.es/ecma262/#sec-array.isarray +$({ target: 'Array', stat: true }, { + isArray: isArray +}); + + +/***/ }), +/* 175 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__(12); +var addToUnscopables = __webpack_require__(145); +var Iterators = __webpack_require__(138); +var InternalStateModule = __webpack_require__(51); +var defineProperty = __webpack_require__(44).f; +var defineIterator = __webpack_require__(176); +var createIterResultObject = __webpack_require__(179); +var IS_PURE = __webpack_require__(36); +var DESCRIPTORS = __webpack_require__(6); + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +module.exports = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = null; + return createIterResultObject(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject(index, false); + case 'values': return createIterResultObject(target[index], false); + } return createIterResultObject([index, target[index]], false); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +var values = Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +// V8 ~ Chrome 45- bug +if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try { + defineProperty(values, 'name', { value: 'values' }); +} catch (error) { /* empty */ } + + +/***/ }), +/* 176 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var IS_PURE = __webpack_require__(36); +var FunctionName = __webpack_require__(49); +var isCallable = __webpack_require__(21); +var createIteratorConstructor = __webpack_require__(177); +var getPrototypeOf = __webpack_require__(134); +var setPrototypeOf = __webpack_require__(118); +var setToStringTag = __webpack_require__(82); +var createNonEnumerableProperty = __webpack_require__(43); +var defineBuiltIn = __webpack_require__(47); +var wellKnownSymbol = __webpack_require__(33); +var Iterators = __webpack_require__(138); +var IteratorsCore = __webpack_require__(178); + +var PROPER_FUNCTION_NAME = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) { + defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); + if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis; + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn(IterablePrototype, KEY, methods[KEY]); + } + } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT }); + } + Iterators[NAME] = defaultIterator; + + return methods; +}; + + +/***/ }), +/* 177 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var IteratorPrototype = __webpack_require__(178).IteratorPrototype; +var create = __webpack_require__(71); +var createPropertyDescriptor = __webpack_require__(11); +var setToStringTag = __webpack_require__(82); +var Iterators = __webpack_require__(138); + +var returnThis = function () { return this; }; + +module.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; +}; + + +/***/ }), +/* 178 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var create = __webpack_require__(71); +var getPrototypeOf = __webpack_require__(134); +var defineBuiltIn = __webpack_require__(47); +var wellKnownSymbol = __webpack_require__(33); +var IS_PURE = __webpack_require__(36); + +var ITERATOR = wellKnownSymbol('iterator'); +var BUGGY_SAFARI_ITERATORS = false; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; + +/* eslint-disable es/no-array-prototype-keys -- safe */ +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype[ITERATOR].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {}; +else if (IS_PURE) IteratorPrototype = create(IteratorPrototype); + +// `%IteratorPrototype%[@@iterator]()` method +// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator +if (!isCallable(IteratorPrototype[ITERATOR])) { + defineBuiltIn(IteratorPrototype, ITERATOR, function () { + return this; + }); +} + +module.exports = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS +}; + + +/***/ }), +/* 179 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// `CreateIterResultObject` abstract operation +// https://tc39.es/ecma262/#sec-createiterresultobject +module.exports = function (value, done) { + return { value: value, done: done }; +}; + + +/***/ }), +/* 180 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var IndexedObject = __webpack_require__(13); +var toIndexedObject = __webpack_require__(12); +var arrayMethodIsStrict = __webpack_require__(154); + +var nativeJoin = uncurryThis([].join); + +var ES3_STRINGS = IndexedObject !== Object; +var FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ','); + +// `Array.prototype.join` method +// https://tc39.es/ecma262/#sec-array.prototype.join +$({ target: 'Array', proto: true, forced: FORCED }, { + join: function join(separator) { + return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator); + } +}); + + +/***/ }), +/* 181 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var lastIndexOf = __webpack_require__(182); + +// `Array.prototype.lastIndexOf` method +// https://tc39.es/ecma262/#sec-array.prototype.lastindexof +// eslint-disable-next-line es/no-array-prototype-lastindexof -- required for testing +$({ target: 'Array', proto: true, forced: lastIndexOf !== [].lastIndexOf }, { + lastIndexOf: lastIndexOf +}); + + +/***/ }), +/* 182 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-array-prototype-lastindexof -- safe */ +var apply = __webpack_require__(95); +var toIndexedObject = __webpack_require__(12); +var toIntegerOrInfinity = __webpack_require__(61); +var lengthOfArrayLike = __webpack_require__(63); +var arrayMethodIsStrict = __webpack_require__(154); + +var min = Math.min; +var $lastIndexOf = [].lastIndexOf; +var NEGATIVE_ZERO = !!$lastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0; +var STRICT_METHOD = arrayMethodIsStrict('lastIndexOf'); +var FORCED = NEGATIVE_ZERO || !STRICT_METHOD; + +// `Array.prototype.lastIndexOf` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.lastindexof +module.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { + // convert -0 to +0 + if (NEGATIVE_ZERO) return apply($lastIndexOf, this, arguments) || 0; + var O = toIndexedObject(this); + var length = lengthOfArrayLike(O); + if (length === 0) return -1; + var index = length - 1; + if (arguments.length > 1) index = min(index, toIntegerOrInfinity(arguments[1])); + if (index < 0) index = length + index; + for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0; + return -1; +} : $lastIndexOf; + + +/***/ }), +/* 183 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $map = __webpack_require__(83).map; +var arrayMethodHasSpeciesSupport = __webpack_require__(149); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map'); + +// `Array.prototype.map` method +// https://tc39.es/ecma262/#sec-array.prototype.map +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 184 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var isConstructor = __webpack_require__(89); +var createProperty = __webpack_require__(90); +var setArrayLength = __webpack_require__(148); + +var $Array = Array; + +var ISNT_GENERIC = fails(function () { + function F() { /* empty */ } + // eslint-disable-next-line es/no-array-of -- safe + return !($Array.of.call(F) instanceof F); +}); + +// `Array.of` method +// https://tc39.es/ecma262/#sec-array.of +// WebKit Array.of isn't generic +$({ target: 'Array', stat: true, forced: ISNT_GENERIC }, { + of: function of(/* ...args */) { + var index = 0; + var argumentsLength = arguments.length; + var result = new (isConstructor(this) ? this : $Array)(argumentsLength); + while (argumentsLength > index) createProperty(result, index, arguments[index++]); + setArrayLength(result, argumentsLength); + return result; + } +}); + + +/***/ }), +/* 185 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var setArrayLength = __webpack_require__(148); +var doesNotExceedSafeInteger = __webpack_require__(147); +var fails = __webpack_require__(7); + +var INCORRECT_TO_LENGTH = fails(function () { + return [].push.call({ length: 0x100000000 }, 1) !== 4294967297; +}); + +// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError +// https://bugs.chromium.org/p/v8/issues/detail?id=12681 +var properErrorOnNonWritableLength = function () { + try { + // eslint-disable-next-line es/no-object-defineproperty -- safe + Object.defineProperty([], 'length', { writable: false }).push(); + } catch (error) { + return error instanceof TypeError; + } +}; + +var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength(); + +// `Array.prototype.push` method +// https://tc39.es/ecma262/#sec-array.prototype.push +$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + push: function push(item) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + var argCount = arguments.length; + doesNotExceedSafeInteger(len + argCount); + for (var i = 0; i < argCount; i++) { + O[len] = arguments[i]; + len++; + } + setArrayLength(O, len); + return len; + } +}); + + +/***/ }), +/* 186 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $reduce = __webpack_require__(187).left; +var arrayMethodIsStrict = __webpack_require__(154); +var CHROME_VERSION = __webpack_require__(27); +var IS_NODE = __webpack_require__(188); + +// Chrome 80-82 has a critical bug +// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982 +var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83; +var FORCED = CHROME_BUG || !arrayMethodIsStrict('reduce'); + +// `Array.prototype.reduce` method +// https://tc39.es/ecma262/#sec-array.prototype.reduce +$({ target: 'Array', proto: true, forced: FORCED }, { + reduce: function reduce(callbackfn /* , initialValue */) { + var length = arguments.length; + return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 187 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aCallable = __webpack_require__(30); +var toObject = __webpack_require__(39); +var IndexedObject = __webpack_require__(13); +var lengthOfArrayLike = __webpack_require__(63); + +var $TypeError = TypeError; + +var REDUCE_EMPTY = 'Reduce of empty array with no initial value'; + +// `Array.prototype.{ reduce, reduceRight }` methods implementation +var createMethod = function (IS_RIGHT) { + return function (that, callbackfn, argumentsLength, memo) { + var O = toObject(that); + var self = IndexedObject(O); + var length = lengthOfArrayLike(O); + aCallable(callbackfn); + if (length === 0 && argumentsLength < 2) throw new $TypeError(REDUCE_EMPTY); + var index = IS_RIGHT ? length - 1 : 0; + var i = IS_RIGHT ? -1 : 1; + if (argumentsLength < 2) while (true) { + if (index in self) { + memo = self[index]; + index += i; + break; + } + index += i; + if (IS_RIGHT ? index < 0 : length <= index) { + throw new $TypeError(REDUCE_EMPTY); + } + } + for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) { + memo = callbackfn(memo, self[index], index, O); + } + return memo; + }; +}; + +module.exports = { + // `Array.prototype.reduce` method + // https://tc39.es/ecma262/#sec-array.prototype.reduce + left: createMethod(false), + // `Array.prototype.reduceRight` method + // https://tc39.es/ecma262/#sec-array.prototype.reduceright + right: createMethod(true) +}; + + +/***/ }), +/* 188 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ENVIRONMENT = __webpack_require__(189); + +module.exports = ENVIRONMENT === 'NODE'; + + +/***/ }), +/* 189 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* global Bun, Deno -- detection */ +var globalThis = __webpack_require__(4); +var userAgent = __webpack_require__(28); +var classof = __webpack_require__(15); + +var userAgentStartsWith = function (string) { + return userAgent.slice(0, string.length) === string; +}; + +module.exports = (function () { + if (userAgentStartsWith('Bun/')) return 'BUN'; + if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE'; + if (userAgentStartsWith('Deno/')) return 'DENO'; + if (userAgentStartsWith('Node.js/')) return 'NODE'; + if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN'; + if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO'; + if (classof(globalThis.process) === 'process') return 'NODE'; + if (globalThis.window && globalThis.document) return 'BROWSER'; + return 'REST'; +})(); + + +/***/ }), +/* 190 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $reduceRight = __webpack_require__(187).right; +var arrayMethodIsStrict = __webpack_require__(154); +var CHROME_VERSION = __webpack_require__(27); +var IS_NODE = __webpack_require__(188); + +// Chrome 80-82 has a critical bug +// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982 +var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83; +var FORCED = CHROME_BUG || !arrayMethodIsStrict('reduceRight'); + +// `Array.prototype.reduceRight` method +// https://tc39.es/ecma262/#sec-array.prototype.reduceright +$({ target: 'Array', proto: true, forced: FORCED }, { + reduceRight: function reduceRight(callbackfn /* , initialValue */) { + return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 191 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var isArray = __webpack_require__(88); + +var nativeReverse = uncurryThis([].reverse); +var test = [1, 2]; + +// `Array.prototype.reverse` method +// https://tc39.es/ecma262/#sec-array.prototype.reverse +// fix for Safari 12.0 bug +// https://bugs.webkit.org/show_bug.cgi?id=188794 +$({ target: 'Array', proto: true, forced: String(test) === String(test.reverse()) }, { + reverse: function reverse() { + // eslint-disable-next-line no-self-assign -- dirty hack + if (isArray(this)) this.length = this.length; + return nativeReverse(this); + } +}); + + +/***/ }), +/* 192 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isArray = __webpack_require__(88); +var isConstructor = __webpack_require__(89); +var isObject = __webpack_require__(20); +var toAbsoluteIndex = __webpack_require__(60); +var lengthOfArrayLike = __webpack_require__(63); +var toIndexedObject = __webpack_require__(12); +var createProperty = __webpack_require__(90); +var setArrayLength = __webpack_require__(148); +var wellKnownSymbol = __webpack_require__(33); +var arrayMethodHasSpeciesSupport = __webpack_require__(149); +var nativeSlice = __webpack_require__(76); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice'); + +var SPECIES = wellKnownSymbol('species'); +var $Array = Array; +var max = Math.max; + +// `Array.prototype.slice` method +// https://tc39.es/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + slice: function slice(start, end) { + var O = toIndexedObject(this); + var length = lengthOfArrayLike(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject(Constructor)) { + Constructor = Constructor[SPECIES]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === $Array || Constructor === undefined) { + return nativeSlice(O, k, fin); + } + } + result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); + setArrayLength(result, n); + return result; + } +}); + + +/***/ }), +/* 193 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $some = __webpack_require__(83).some; +var arrayMethodIsStrict = __webpack_require__(154); + +var STRICT_METHOD = arrayMethodIsStrict('some'); + +// `Array.prototype.some` method +// https://tc39.es/ecma262/#sec-array.prototype.some +$({ target: 'Array', proto: true, forced: !STRICT_METHOD }, { + some: function some(callbackfn /* , thisArg */) { + return $some(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 194 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var deletePropertyOrThrow = __webpack_require__(152); +var toString = __webpack_require__(68); +var fails = __webpack_require__(7); +var internalSort = __webpack_require__(195); +var arrayMethodIsStrict = __webpack_require__(154); +var FF = __webpack_require__(196); +var IE_OR_EDGE = __webpack_require__(197); +var V8 = __webpack_require__(27); +var WEBKIT = __webpack_require__(198); + +var test = []; +var nativeSort = uncurryThis(test.sort); +var push = uncurryThis(test.push); + +// IE8- +var FAILS_ON_UNDEFINED = fails(function () { + test.sort(undefined); +}); +// V8 bug +var FAILS_ON_NULL = fails(function () { + test.sort(null); +}); +// Old WebKit +var STRICT_METHOD = arrayMethodIsStrict('sort'); + +var STABLE_SORT = !fails(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 70; + if (FF && FF > 3) return; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 603; + + var result = ''; + var code, chr, value, index; + + // generate an array with more 512 elements (Chakra and old V8 fails only in this case) + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + + switch (code) { + case 66: case 69: case 70: case 72: value = 3; break; + case 68: case 71: value = 4; break; + default: value = 2; + } + + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + + test.sort(function (a, b) { return b.v - a.v; }); + + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) result += chr; + } + + return result !== 'DGBEFHACIJK'; +}); + +var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT; + +var getSortCompare = function (comparefn) { + return function (x, y) { + if (y === undefined) return -1; + if (x === undefined) return 1; + if (comparefn !== undefined) return +comparefn(x, y) || 0; + var xString = toString(x); + var yString = toString(y); + return xString === yString ? 0 : xString > yString ? 1 : -1; + }; +}; + +// `Array.prototype.sort` method +// https://tc39.es/ecma262/#sec-array.prototype.sort +$({ target: 'Array', proto: true, forced: FORCED }, { + sort: function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + + var array = toObject(this); + + if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn); + + var items = []; + var arrayLength = lengthOfArrayLike(array); + var itemsLength, index; + + for (index = 0; index < arrayLength; index++) { + if (index in array) push(items, array[index]); + } + + internalSort(items, getSortCompare(comparefn)); + + itemsLength = lengthOfArrayLike(items); + index = 0; + + while (index < itemsLength) array[index] = items[index++]; + while (index < arrayLength) deletePropertyOrThrow(array, index++); + + return array; + } +}); + + +/***/ }), +/* 195 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var arraySlice = __webpack_require__(76); + +var floor = Math.floor; + +var sort = function (array, comparefn) { + var length = array.length; + + if (length < 8) { + // insertion sort + var i = 1; + var element, j; + + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) array[j] = element; + } + } else { + // merge sort + var middle = floor(length / 2); + var left = sort(arraySlice(array, 0, middle), comparefn); + var right = sort(arraySlice(array, middle), comparefn); + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } + } + + return array; +}; + +module.exports = sort; + + +/***/ }), +/* 196 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(28); + +var firefox = userAgent.match(/firefox\/(\d+)/i); + +module.exports = !!firefox && +firefox[1]; + + +/***/ }), +/* 197 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var UA = __webpack_require__(28); + +module.exports = /MSIE|Trident/.test(UA); + + +/***/ }), +/* 198 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(28); + +var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + +module.exports = !!webkit && +webkit[1]; + + +/***/ }), +/* 199 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var setSpecies = __webpack_require__(200); + +// `Array[@@species]` getter +// https://tc39.es/ecma262/#sec-get-array-@@species +setSpecies('Array'); + + +/***/ }), +/* 200 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var defineBuiltInAccessor = __webpack_require__(77); +var wellKnownSymbol = __webpack_require__(33); +var DESCRIPTORS = __webpack_require__(6); + +var SPECIES = wellKnownSymbol('species'); + +module.exports = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn(CONSTRUCTOR_NAME); + + if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { + defineBuiltInAccessor(Constructor, SPECIES, { + configurable: true, + get: function () { return this; } + }); + } +}; + + +/***/ }), +/* 201 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toObject = __webpack_require__(39); +var toAbsoluteIndex = __webpack_require__(60); +var toIntegerOrInfinity = __webpack_require__(61); +var lengthOfArrayLike = __webpack_require__(63); +var setArrayLength = __webpack_require__(148); +var doesNotExceedSafeInteger = __webpack_require__(147); +var arraySpeciesCreate = __webpack_require__(86); +var createProperty = __webpack_require__(90); +var deletePropertyOrThrow = __webpack_require__(152); +var arrayMethodHasSpeciesSupport = __webpack_require__(149); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('splice'); + +var max = Math.max; +var min = Math.min; + +// `Array.prototype.splice` method +// https://tc39.es/ecma262/#sec-array.prototype.splice +// with adding support of @@species +$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + splice: function splice(start, deleteCount /* , ...items */) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var insertCount, actualDeleteCount, A, k, from, to; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart); + } + doesNotExceedSafeInteger(len + insertCount - actualDeleteCount); + A = arraySpeciesCreate(O, actualDeleteCount); + for (k = 0; k < actualDeleteCount; k++) { + from = actualStart + k; + if (from in O) createProperty(A, k, O[from]); + } + setArrayLength(A, actualDeleteCount); + if (insertCount < actualDeleteCount) { + for (k = actualStart; k < len - actualDeleteCount; k++) { + from = k + actualDeleteCount; + to = k + insertCount; + if (from in O) O[to] = O[from]; + else deletePropertyOrThrow(O, to); + } + for (k = len; k > len - actualDeleteCount + insertCount; k--) deletePropertyOrThrow(O, k - 1); + } else if (insertCount > actualDeleteCount) { + for (k = len - actualDeleteCount; k > actualStart; k--) { + from = k + actualDeleteCount - 1; + to = k + insertCount - 1; + if (from in O) O[to] = O[from]; + else deletePropertyOrThrow(O, to); + } + } + for (k = 0; k < insertCount; k++) { + O[k + actualStart] = arguments[k + 2]; + } + setArrayLength(O, len - actualDeleteCount + insertCount); + return A; + } +}); + + +/***/ }), +/* 202 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var lengthOfArrayLike = __webpack_require__(63); +var toIndexedObject = __webpack_require__(12); +var createProperty = __webpack_require__(90); +var addToUnscopables = __webpack_require__(145); + +var $Array = Array; + +// `Array.prototype.toReversed` method +// https://tc39.es/ecma262/#sec-array.prototype.toreversed +$({ target: 'Array', proto: true }, { + toReversed: function toReversed() { + var O = toIndexedObject(this); + var len = lengthOfArrayLike(O); + var A = new $Array(len); + var k = 0; + for (; k < len; k++) createProperty(A, k, O[len - k - 1]); + return A; + } +}); + +addToUnscopables('toReversed'); + + +/***/ }), +/* 203 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); +var toIndexedObject = __webpack_require__(12); +var arrayFromConstructorAndList = __webpack_require__(204); +var getBuiltInPrototypeMethod = __webpack_require__(205); +var addToUnscopables = __webpack_require__(145); + +var $Array = Array; +var sort = uncurryThis(getBuiltInPrototypeMethod('Array', 'sort')); + +// `Array.prototype.toSorted` method +// https://tc39.es/ecma262/#sec-array.prototype.tosorted +$({ target: 'Array', proto: true }, { + toSorted: function toSorted(compareFn) { + if (compareFn !== undefined) aCallable(compareFn); + var O = toIndexedObject(this); + var A = arrayFromConstructorAndList($Array, O); + return sort(A, compareFn); + } +}); + +addToUnscopables('toSorted'); + + +/***/ }), +/* 204 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var lengthOfArrayLike = __webpack_require__(63); + +module.exports = function (Constructor, list, $length) { + var index = 0; + var length = arguments.length > 2 ? $length : lengthOfArrayLike(list); + var result = new Constructor(length); + while (length > index) result[index] = list[index++]; + return result; +}; + + +/***/ }), +/* 205 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +module.exports = function (CONSTRUCTOR, METHOD) { + var Constructor = globalThis[CONSTRUCTOR]; + var Prototype = Constructor && Constructor.prototype; + return Prototype && Prototype[METHOD]; +}; + + +/***/ }), +/* 206 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var addToUnscopables = __webpack_require__(145); +var doesNotExceedSafeInteger = __webpack_require__(147); +var lengthOfArrayLike = __webpack_require__(63); +var toAbsoluteIndex = __webpack_require__(60); +var toIndexedObject = __webpack_require__(12); +var toIntegerOrInfinity = __webpack_require__(61); +var createProperty = __webpack_require__(90); + +var $Array = Array; +var max = Math.max; +var min = Math.min; + +// `Array.prototype.toSpliced` method +// https://tc39.es/ecma262/#sec-array.prototype.tospliced +$({ target: 'Array', proto: true }, { + toSpliced: function toSpliced(start, deleteCount /* , ...items */) { + var O = toIndexedObject(this); + var len = lengthOfArrayLike(O); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var k = 0; + var insertCount, actualDeleteCount, newLen, A; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart); + } + newLen = doesNotExceedSafeInteger(len + insertCount - actualDeleteCount); + A = $Array(newLen); + + for (; k < actualStart; k++) createProperty(A, k, O[k]); + for (; k < actualStart + insertCount; k++) createProperty(A, k, arguments[k - actualStart + 2]); + for (; k < newLen; k++) createProperty(A, k, O[k + actualDeleteCount - insertCount]); + + return A; + } +}); + +addToUnscopables('toSpliced'); + + +/***/ }), +/* 207 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// this method was added to unscopables after implementation +// in popular engines, so it's moved to a separate module +var addToUnscopables = __webpack_require__(145); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('flat'); + + +/***/ }), +/* 208 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// this method was added to unscopables after implementation +// in popular engines, so it's moved to a separate module +var addToUnscopables = __webpack_require__(145); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('flatMap'); + + +/***/ }), +/* 209 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var setArrayLength = __webpack_require__(148); +var deletePropertyOrThrow = __webpack_require__(152); +var doesNotExceedSafeInteger = __webpack_require__(147); + +// IE8- +var INCORRECT_RESULT = [].unshift(0) !== 1; + +// V8 ~ Chrome < 71 and Safari <= 15.4, FF < 23 throws InternalError +var properErrorOnNonWritableLength = function () { + try { + // eslint-disable-next-line es/no-object-defineproperty -- safe + Object.defineProperty([], 'length', { writable: false }).unshift(); + } catch (error) { + return error instanceof TypeError; + } +}; + +var FORCED = INCORRECT_RESULT || !properErrorOnNonWritableLength(); + +// `Array.prototype.unshift` method +// https://tc39.es/ecma262/#sec-array.prototype.unshift +$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + unshift: function unshift(item) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + var argCount = arguments.length; + if (argCount) { + doesNotExceedSafeInteger(len + argCount); + var k = len; + while (k--) { + var to = k + argCount; + if (k in O) O[to] = O[k]; + else deletePropertyOrThrow(O, to); + } + for (var j = 0; j < argCount; j++) { + O[j] = arguments[j]; + } + } return setArrayLength(O, len + argCount); + } +}); + + +/***/ }), +/* 210 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var lengthOfArrayLike = __webpack_require__(63); +var toIntegerOrInfinity = __webpack_require__(61); +var toIndexedObject = __webpack_require__(12); +var createProperty = __webpack_require__(90); + +var $Array = Array; +var $RangeError = RangeError; + +// Firefox bug +var INCORRECT_EXCEPTION_ON_COERCION_FAIL = (function () { + try { + // eslint-disable-next-line es/no-array-prototype-with, no-throw-literal -- needed for testing + []['with']({ valueOf: function () { throw 4; } }, null); + } catch (error) { + return error !== 4; + } +})(); + +// `Array.prototype.with` method +// https://tc39.es/ecma262/#sec-array.prototype.with +$({ target: 'Array', proto: true, forced: INCORRECT_EXCEPTION_ON_COERCION_FAIL }, { + 'with': function (index, value) { + var O = toIndexedObject(this); + var len = lengthOfArrayLike(O); + var relativeIndex = toIntegerOrInfinity(index); + var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex; + if (actualIndex >= len || actualIndex < 0) throw new $RangeError('Incorrect index'); + var A = new $Array(len); + var k = 0; + for (; k < len; k++) createProperty(A, k, k === actualIndex ? value : O[k]); + return A; + } +}); + + +/***/ }), +/* 211 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var arrayBufferModule = __webpack_require__(212); +var setSpecies = __webpack_require__(200); + +var ARRAY_BUFFER = 'ArrayBuffer'; +var ArrayBuffer = arrayBufferModule[ARRAY_BUFFER]; +var NativeArrayBuffer = globalThis[ARRAY_BUFFER]; + +// `ArrayBuffer` constructor +// https://tc39.es/ecma262/#sec-arraybuffer-constructor +$({ global: true, constructor: true, forced: NativeArrayBuffer !== ArrayBuffer }, { + ArrayBuffer: ArrayBuffer +}); + +setSpecies(ARRAY_BUFFER); + + +/***/ }), +/* 212 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var DESCRIPTORS = __webpack_require__(6); +var NATIVE_ARRAY_BUFFER = __webpack_require__(213); +var FunctionName = __webpack_require__(49); +var createNonEnumerableProperty = __webpack_require__(43); +var defineBuiltInAccessor = __webpack_require__(77); +var defineBuiltIns = __webpack_require__(214); +var fails = __webpack_require__(7); +var anInstance = __webpack_require__(215); +var toIntegerOrInfinity = __webpack_require__(61); +var toIndex = __webpack_require__(216); +var fround = __webpack_require__(217); +var IEEE754 = __webpack_require__(221); +var getPrototypeOf = __webpack_require__(134); +var setPrototypeOf = __webpack_require__(118); +var arrayFill = __webpack_require__(156); +var arraySlice = __webpack_require__(76); +var inheritIfRequired = __webpack_require__(123); +var copyConstructorProperties = __webpack_require__(55); +var setToStringTag = __webpack_require__(82); +var InternalStateModule = __webpack_require__(51); + +var PROPER_FUNCTION_NAME = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var ARRAY_BUFFER = 'ArrayBuffer'; +var DATA_VIEW = 'DataView'; +var PROTOTYPE = 'prototype'; +var WRONG_LENGTH = 'Wrong length'; +var WRONG_INDEX = 'Wrong index'; +var getInternalArrayBufferState = InternalStateModule.getterFor(ARRAY_BUFFER); +var getInternalDataViewState = InternalStateModule.getterFor(DATA_VIEW); +var setInternalState = InternalStateModule.set; +var NativeArrayBuffer = globalThis[ARRAY_BUFFER]; +var $ArrayBuffer = NativeArrayBuffer; +var ArrayBufferPrototype = $ArrayBuffer && $ArrayBuffer[PROTOTYPE]; +var $DataView = globalThis[DATA_VIEW]; +var DataViewPrototype = $DataView && $DataView[PROTOTYPE]; +var ObjectPrototype = Object.prototype; +var Array = globalThis.Array; +var RangeError = globalThis.RangeError; +var fill = uncurryThis(arrayFill); +var reverse = uncurryThis([].reverse); + +var packIEEE754 = IEEE754.pack; +var unpackIEEE754 = IEEE754.unpack; + +var packInt8 = function (number) { + return [number & 0xFF]; +}; + +var packInt16 = function (number) { + return [number & 0xFF, number >> 8 & 0xFF]; +}; + +var packInt32 = function (number) { + return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF]; +}; + +var unpackInt32 = function (buffer) { + return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0]; +}; + +var packFloat32 = function (number) { + return packIEEE754(fround(number), 23, 4); +}; + +var packFloat64 = function (number) { + return packIEEE754(number, 52, 8); +}; + +var addGetter = function (Constructor, key, getInternalState) { + defineBuiltInAccessor(Constructor[PROTOTYPE], key, { + configurable: true, + get: function () { + return getInternalState(this)[key]; + } + }); +}; + +var get = function (view, count, index, isLittleEndian) { + var store = getInternalDataViewState(view); + var intIndex = toIndex(index); + var boolIsLittleEndian = !!isLittleEndian; + if (intIndex + count > store.byteLength) throw new RangeError(WRONG_INDEX); + var bytes = store.bytes; + var start = intIndex + store.byteOffset; + var pack = arraySlice(bytes, start, start + count); + return boolIsLittleEndian ? pack : reverse(pack); +}; + +var set = function (view, count, index, conversion, value, isLittleEndian) { + var store = getInternalDataViewState(view); + var intIndex = toIndex(index); + var pack = conversion(+value); + var boolIsLittleEndian = !!isLittleEndian; + if (intIndex + count > store.byteLength) throw new RangeError(WRONG_INDEX); + var bytes = store.bytes; + var start = intIndex + store.byteOffset; + for (var i = 0; i < count; i++) bytes[start + i] = pack[boolIsLittleEndian ? i : count - i - 1]; +}; + +if (!NATIVE_ARRAY_BUFFER) { + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, ArrayBufferPrototype); + var byteLength = toIndex(length); + setInternalState(this, { + type: ARRAY_BUFFER, + bytes: fill(Array(byteLength), 0), + byteLength: byteLength + }); + if (!DESCRIPTORS) { + this.byteLength = byteLength; + this.detached = false; + } + }; + + ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE]; + + $DataView = function DataView(buffer, byteOffset, byteLength) { + anInstance(this, DataViewPrototype); + anInstance(buffer, ArrayBufferPrototype); + var bufferState = getInternalArrayBufferState(buffer); + var bufferLength = bufferState.byteLength; + var offset = toIntegerOrInfinity(byteOffset); + if (offset < 0 || offset > bufferLength) throw new RangeError('Wrong offset'); + byteLength = byteLength === undefined ? bufferLength - offset : toIndex(byteLength); + if (offset + byteLength > bufferLength) throw new RangeError(WRONG_LENGTH); + setInternalState(this, { + type: DATA_VIEW, + buffer: buffer, + byteLength: byteLength, + byteOffset: offset, + bytes: bufferState.bytes + }); + if (!DESCRIPTORS) { + this.buffer = buffer; + this.byteLength = byteLength; + this.byteOffset = offset; + } + }; + + DataViewPrototype = $DataView[PROTOTYPE]; + + if (DESCRIPTORS) { + addGetter($ArrayBuffer, 'byteLength', getInternalArrayBufferState); + addGetter($DataView, 'buffer', getInternalDataViewState); + addGetter($DataView, 'byteLength', getInternalDataViewState); + addGetter($DataView, 'byteOffset', getInternalDataViewState); + } + + defineBuiltIns(DataViewPrototype, { + getInt8: function getInt8(byteOffset) { + return get(this, 1, byteOffset)[0] << 24 >> 24; + }, + getUint8: function getUint8(byteOffset) { + return get(this, 1, byteOffset)[0]; + }, + getInt16: function getInt16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : false); + return (bytes[1] << 8 | bytes[0]) << 16 >> 16; + }, + getUint16: function getUint16(byteOffset /* , littleEndian */) { + var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : false); + return bytes[1] << 8 | bytes[0]; + }, + getInt32: function getInt32(byteOffset /* , littleEndian */) { + return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : false)); + }, + getUint32: function getUint32(byteOffset /* , littleEndian */) { + return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : false)) >>> 0; + }, + getFloat32: function getFloat32(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : false), 23); + }, + getFloat64: function getFloat64(byteOffset /* , littleEndian */) { + return unpackIEEE754(get(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : false), 52); + }, + setInt8: function setInt8(byteOffset, value) { + set(this, 1, byteOffset, packInt8, value); + }, + setUint8: function setUint8(byteOffset, value) { + set(this, 1, byteOffset, packInt8, value); + }, + setInt16: function setInt16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : false); + }, + setUint16: function setUint16(byteOffset, value /* , littleEndian */) { + set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : false); + }, + setInt32: function setInt32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : false); + }, + setUint32: function setUint32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : false); + }, + setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) { + set(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : false); + }, + setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) { + set(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : false); + } + }); +} else { + var INCORRECT_ARRAY_BUFFER_NAME = PROPER_FUNCTION_NAME && NativeArrayBuffer.name !== ARRAY_BUFFER; + /* eslint-disable no-new, sonarjs/inconsistent-function-call -- required for testing */ + if (!fails(function () { + NativeArrayBuffer(1); + }) || !fails(function () { + new NativeArrayBuffer(-1); + }) || fails(function () { + new NativeArrayBuffer(); + new NativeArrayBuffer(1.5); + new NativeArrayBuffer(NaN); + return NativeArrayBuffer.length !== 1 || INCORRECT_ARRAY_BUFFER_NAME && !CONFIGURABLE_FUNCTION_NAME; + })) { + /* eslint-enable no-new, sonarjs/inconsistent-function-call -- required for testing */ + $ArrayBuffer = function ArrayBuffer(length) { + anInstance(this, ArrayBufferPrototype); + return inheritIfRequired(new NativeArrayBuffer(toIndex(length)), this, $ArrayBuffer); + }; + + $ArrayBuffer[PROTOTYPE] = ArrayBufferPrototype; + + ArrayBufferPrototype.constructor = $ArrayBuffer; + + copyConstructorProperties($ArrayBuffer, NativeArrayBuffer); + } else if (INCORRECT_ARRAY_BUFFER_NAME && CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty(NativeArrayBuffer, 'name', ARRAY_BUFFER); + } + + // WebKit bug - the same parent prototype for typed arrays and data view + if (setPrototypeOf && getPrototypeOf(DataViewPrototype) !== ObjectPrototype) { + setPrototypeOf(DataViewPrototype, ObjectPrototype); + } + + // iOS Safari 7.x bug + var testView = new $DataView(new $ArrayBuffer(2)); + var $setInt8 = uncurryThis(DataViewPrototype.setInt8); + testView.setInt8(0, 2147483648); + testView.setInt8(1, 2147483649); + if (testView.getInt8(0) || !testView.getInt8(1)) defineBuiltIns(DataViewPrototype, { + setInt8: function setInt8(byteOffset, value) { + $setInt8(this, byteOffset, value << 24 >> 24); + }, + setUint8: function setUint8(byteOffset, value) { + $setInt8(this, byteOffset, value << 24 >> 24); + } + }, { unsafe: true }); +} + +setToStringTag($ArrayBuffer, ARRAY_BUFFER); +setToStringTag($DataView, DATA_VIEW); + +module.exports = { + ArrayBuffer: $ArrayBuffer, + DataView: $DataView +}; + + +/***/ }), +/* 213 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// eslint-disable-next-line es/no-typed-arrays -- safe +module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined'; + + +/***/ }), +/* 214 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineBuiltIn = __webpack_require__(47); + +module.exports = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; +}; + + +/***/ }), +/* 215 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isPrototypeOf = __webpack_require__(24); + +var $TypeError = TypeError; + +module.exports = function (it, Prototype) { + if (isPrototypeOf(Prototype, it)) return it; + throw new $TypeError('Incorrect invocation'); +}; + + +/***/ }), +/* 216 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(61); +var toLength = __webpack_require__(64); + +var $RangeError = RangeError; + +// `ToIndex` abstract operation +// https://tc39.es/ecma262/#sec-toindex +module.exports = function (it) { + if (it === undefined) return 0; + var number = toIntegerOrInfinity(it); + var length = toLength(number); + if (number !== length) throw new $RangeError('Wrong length or index'); + return length; +}; + + +/***/ }), +/* 217 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var floatRound = __webpack_require__(218); + +var FLOAT32_EPSILON = 1.1920928955078125e-7; // 2 ** -23; +var FLOAT32_MAX_VALUE = 3.4028234663852886e+38; // 2 ** 128 - 2 ** 104 +var FLOAT32_MIN_VALUE = 1.1754943508222875e-38; // 2 ** -126; + +// `Math.fround` method implementation +// https://tc39.es/ecma262/#sec-math.fround +// eslint-disable-next-line es/no-math-fround -- safe +module.exports = Math.fround || function fround(x) { + return floatRound(x, FLOAT32_EPSILON, FLOAT32_MAX_VALUE, FLOAT32_MIN_VALUE); +}; + + +/***/ }), +/* 218 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var sign = __webpack_require__(219); +var roundTiesToEven = __webpack_require__(220); + +var abs = Math.abs; + +var EPSILON = 2.220446049250313e-16; // Number.EPSILON + +module.exports = function (x, FLOAT_EPSILON, FLOAT_MAX_VALUE, FLOAT_MIN_VALUE) { + var n = +x; + var absolute = abs(n); + var s = sign(n); + if (absolute < FLOAT_MIN_VALUE) return s * roundTiesToEven(absolute / FLOAT_MIN_VALUE / FLOAT_EPSILON) * FLOAT_MIN_VALUE * FLOAT_EPSILON; + var a = (1 + FLOAT_EPSILON / EPSILON) * absolute; + var result = a - (a - absolute); + // eslint-disable-next-line no-self-compare -- NaN check + if (result > FLOAT_MAX_VALUE || result !== result) return s * Infinity; + return s * result; +}; + + +/***/ }), +/* 219 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// `Math.sign` method implementation +// https://tc39.es/ecma262/#sec-math.sign +// eslint-disable-next-line es/no-math-sign -- safe +module.exports = Math.sign || function sign(x) { + var n = +x; + // eslint-disable-next-line no-self-compare -- NaN check + return n === 0 || n !== n ? n : n < 0 ? -1 : 1; +}; + + +/***/ }), +/* 220 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var EPSILON = 2.220446049250313e-16; // Number.EPSILON +var INVERSE_EPSILON = 1 / EPSILON; + +module.exports = function (n) { + return n + INVERSE_EPSILON - INVERSE_EPSILON; +}; + + +/***/ }), +/* 221 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// IEEE754 conversions based on https://github.com/feross/ieee754 +var $Array = Array; +var abs = Math.abs; +var pow = Math.pow; +var floor = Math.floor; +var log = Math.log; +var LN2 = Math.LN2; + +var pack = function (number, mantissaLength, bytes) { + var buffer = $Array(bytes); + var exponentLength = bytes * 8 - mantissaLength - 1; + var eMax = (1 << exponentLength) - 1; + var eBias = eMax >> 1; + var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0; + var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0; + var index = 0; + var exponent, mantissa, c; + number = abs(number); + // eslint-disable-next-line no-self-compare -- NaN check + if (number !== number || number === Infinity) { + // eslint-disable-next-line no-self-compare -- NaN check + mantissa = number !== number ? 1 : 0; + exponent = eMax; + } else { + exponent = floor(log(number) / LN2); + c = pow(2, -exponent); + if (number * c < 1) { + exponent--; + c *= 2; + } + if (exponent + eBias >= 1) { + number += rt / c; + } else { + number += rt * pow(2, 1 - eBias); + } + if (number * c >= 2) { + exponent++; + c /= 2; + } + if (exponent + eBias >= eMax) { + mantissa = 0; + exponent = eMax; + } else if (exponent + eBias >= 1) { + mantissa = (number * c - 1) * pow(2, mantissaLength); + exponent += eBias; + } else { + mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength); + exponent = 0; + } + } + while (mantissaLength >= 8) { + buffer[index++] = mantissa & 255; + mantissa /= 256; + mantissaLength -= 8; + } + exponent = exponent << mantissaLength | mantissa; + exponentLength += mantissaLength; + while (exponentLength > 0) { + buffer[index++] = exponent & 255; + exponent /= 256; + exponentLength -= 8; + } + buffer[index - 1] |= sign * 128; + return buffer; +}; + +var unpack = function (buffer, mantissaLength) { + var bytes = buffer.length; + var exponentLength = bytes * 8 - mantissaLength - 1; + var eMax = (1 << exponentLength) - 1; + var eBias = eMax >> 1; + var nBits = exponentLength - 7; + var index = bytes - 1; + var sign = buffer[index--]; + var exponent = sign & 127; + var mantissa; + sign >>= 7; + while (nBits > 0) { + exponent = exponent * 256 + buffer[index--]; + nBits -= 8; + } + mantissa = exponent & (1 << -nBits) - 1; + exponent >>= -nBits; + nBits += mantissaLength; + while (nBits > 0) { + mantissa = mantissa * 256 + buffer[index--]; + nBits -= 8; + } + if (exponent === 0) { + exponent = 1 - eBias; + } else if (exponent === eMax) { + return mantissa ? NaN : sign ? -Infinity : Infinity; + } else { + mantissa += pow(2, mantissaLength); + exponent -= eBias; + } return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength); +}; + +module.exports = { + pack: pack, + unpack: unpack +}; + + +/***/ }), +/* 222 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var ArrayBufferViewCore = __webpack_require__(223); + +var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; + +// `ArrayBuffer.isView` method +// https://tc39.es/ecma262/#sec-arraybuffer.isview +$({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { + isView: ArrayBufferViewCore.isView +}); + + +/***/ }), +/* 223 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NATIVE_ARRAY_BUFFER = __webpack_require__(213); +var DESCRIPTORS = __webpack_require__(6); +var globalThis = __webpack_require__(4); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var hasOwn = __webpack_require__(38); +var classof = __webpack_require__(69); +var tryToString = __webpack_require__(31); +var createNonEnumerableProperty = __webpack_require__(43); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltInAccessor = __webpack_require__(77); +var isPrototypeOf = __webpack_require__(24); +var getPrototypeOf = __webpack_require__(134); +var setPrototypeOf = __webpack_require__(118); +var wellKnownSymbol = __webpack_require__(33); +var uid = __webpack_require__(40); +var InternalStateModule = __webpack_require__(51); + +var enforceInternalState = InternalStateModule.enforce; +var getInternalState = InternalStateModule.get; +var Int8Array = globalThis.Int8Array; +var Int8ArrayPrototype = Int8Array && Int8Array.prototype; +var Uint8ClampedArray = globalThis.Uint8ClampedArray; +var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; +var TypedArray = Int8Array && getPrototypeOf(Int8Array); +var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype); +var ObjectPrototype = Object.prototype; +var TypeError = globalThis.TypeError; + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); +var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor'; +// Fixing native typed arrays in Opera Presto crashes the browser, see #595 +var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera'; +var TYPED_ARRAY_TAG_REQUIRED = false; +var NAME, Constructor, Prototype; + +var TypedArrayConstructorsList = { + Int8Array: 1, + Uint8Array: 1, + Uint8ClampedArray: 1, + Int16Array: 2, + Uint16Array: 2, + Int32Array: 4, + Uint32Array: 4, + Float32Array: 4, + Float64Array: 8 +}; + +var BigIntArrayConstructorsList = { + BigInt64Array: 8, + BigUint64Array: 8 +}; + +var isView = function isView(it) { + if (!isObject(it)) return false; + var klass = classof(it); + return klass === 'DataView' + || hasOwn(TypedArrayConstructorsList, klass) + || hasOwn(BigIntArrayConstructorsList, klass); +}; + +var getTypedArrayConstructor = function (it) { + var proto = getPrototypeOf(it); + if (!isObject(proto)) return; + var state = getInternalState(proto); + return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto); +}; + +var isTypedArray = function (it) { + if (!isObject(it)) return false; + var klass = classof(it); + return hasOwn(TypedArrayConstructorsList, klass) + || hasOwn(BigIntArrayConstructorsList, klass); +}; + +var aTypedArray = function (it) { + if (isTypedArray(it)) return it; + throw new TypeError('Target is not a typed array'); +}; + +var aTypedArrayConstructor = function (C) { + if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C; + throw new TypeError(tryToString(C) + ' is not a typed array constructor'); +}; + +var exportTypedArrayMethod = function (KEY, property, forced, options) { + if (!DESCRIPTORS) return; + if (forced) for (var ARRAY in TypedArrayConstructorsList) { + var TypedArrayConstructor = globalThis[ARRAY]; + if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try { + delete TypedArrayConstructor.prototype[KEY]; + } catch (error) { + // old WebKit bug - some methods are non-configurable + try { + TypedArrayConstructor.prototype[KEY] = property; + } catch (error2) { /* empty */ } + } + } + if (!TypedArrayPrototype[KEY] || forced) { + defineBuiltIn(TypedArrayPrototype, KEY, forced ? property + : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options); + } +}; + +var exportTypedArrayStaticMethod = function (KEY, property, forced) { + var ARRAY, TypedArrayConstructor; + if (!DESCRIPTORS) return; + if (setPrototypeOf) { + if (forced) for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = globalThis[ARRAY]; + if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try { + delete TypedArrayConstructor[KEY]; + } catch (error) { /* empty */ } + } + if (!TypedArray[KEY] || forced) { + // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable + try { + return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property); + } catch (error) { /* empty */ } + } else return; + } + for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = globalThis[ARRAY]; + if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { + defineBuiltIn(TypedArrayConstructor, KEY, property); + } + } +}; + +for (NAME in TypedArrayConstructorsList) { + Constructor = globalThis[NAME]; + Prototype = Constructor && Constructor.prototype; + if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor; + else NATIVE_ARRAY_BUFFER_VIEWS = false; +} + +for (NAME in BigIntArrayConstructorsList) { + Constructor = globalThis[NAME]; + Prototype = Constructor && Constructor.prototype; + if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor; +} + +// WebKit bug - typed arrays constructors prototype is Object.prototype +if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) { + // eslint-disable-next-line no-shadow -- safe + TypedArray = function TypedArray() { + throw new TypeError('Incorrect invocation'); + }; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { + if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray); + } +} + +if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) { + TypedArrayPrototype = TypedArray.prototype; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { + if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype); + } +} + +// WebKit bug - one more object in Uint8ClampedArray prototype chain +if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { + setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); +} + +if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) { + TYPED_ARRAY_TAG_REQUIRED = true; + defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, { + configurable: true, + get: function () { + return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined; + } + }); + for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) { + createNonEnumerableProperty(globalThis[NAME].prototype, TYPED_ARRAY_TAG, NAME); + } +} + +module.exports = { + NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS, + TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG, + aTypedArray: aTypedArray, + aTypedArrayConstructor: aTypedArrayConstructor, + exportTypedArrayMethod: exportTypedArrayMethod, + exportTypedArrayStaticMethod: exportTypedArrayStaticMethod, + getTypedArrayConstructor: getTypedArrayConstructor, + isView: isView, + isTypedArray: isTypedArray, + TypedArray: TypedArray, + TypedArrayPrototype: TypedArrayPrototype +}; + + +/***/ }), +/* 224 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(85); +var fails = __webpack_require__(7); +var ArrayBufferModule = __webpack_require__(212); +var anObject = __webpack_require__(46); +var toAbsoluteIndex = __webpack_require__(60); +var toLength = __webpack_require__(64); + +var ArrayBuffer = ArrayBufferModule.ArrayBuffer; +var DataView = ArrayBufferModule.DataView; +var DataViewPrototype = DataView.prototype; +var nativeArrayBufferSlice = uncurryThis(ArrayBuffer.prototype.slice); +var getUint8 = uncurryThis(DataViewPrototype.getUint8); +var setUint8 = uncurryThis(DataViewPrototype.setUint8); + +var INCORRECT_SLICE = fails(function () { + return !new ArrayBuffer(2).slice(1, undefined).byteLength; +}); + +// `ArrayBuffer.prototype.slice` method +// https://tc39.es/ecma262/#sec-arraybuffer.prototype.slice +$({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, { + slice: function slice(start, end) { + if (nativeArrayBufferSlice && end === undefined) { + return nativeArrayBufferSlice(anObject(this), start); // FF fix + } + var length = anObject(this).byteLength; + var first = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = new ArrayBuffer(toLength(fin - first)); + var viewSource = new DataView(this); + var viewTarget = new DataView(result); + var index = 0; + while (first < fin) { + setUint8(viewTarget, index++, getUint8(viewSource, first++)); + } return result; + } +}); + + +/***/ }), +/* 225 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(226); + + +/***/ }), +/* 226 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var ArrayBufferModule = __webpack_require__(212); +var NATIVE_ARRAY_BUFFER = __webpack_require__(213); + +// `DataView` constructor +// https://tc39.es/ecma262/#sec-dataview-constructor +$({ global: true, constructor: true, forced: !NATIVE_ARRAY_BUFFER }, { + DataView: ArrayBufferModule.DataView +}); + + +/***/ }), +/* 227 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); + +var pow = Math.pow; + +var EXP_MASK16 = 31; // 2 ** 5 - 1 +var SIGNIFICAND_MASK16 = 1023; // 2 ** 10 - 1 +var MIN_SUBNORMAL16 = pow(2, -24); // 2 ** -10 * 2 ** -14 +var SIGNIFICAND_DENOM16 = 0.0009765625; // 2 ** -10 + +var unpackFloat16 = function (bytes) { + var sign = bytes >>> 15; + var exponent = bytes >>> 10 & EXP_MASK16; + var significand = bytes & SIGNIFICAND_MASK16; + if (exponent === EXP_MASK16) return significand === 0 ? sign === 0 ? Infinity : -Infinity : NaN; + if (exponent === 0) return significand * (sign === 0 ? MIN_SUBNORMAL16 : -MIN_SUBNORMAL16); + return pow(2, exponent - 15) * (sign === 0 ? 1 + significand * SIGNIFICAND_DENOM16 : -1 - significand * SIGNIFICAND_DENOM16); +}; + +// eslint-disable-next-line es/no-typed-arrays -- safe +var getUint16 = uncurryThis(DataView.prototype.getUint16); + +// `DataView.prototype.getFloat16` method +// https://tc39.es/ecma262/#sec-dataview.prototype.getfloat16 +$({ target: 'DataView', proto: true }, { + getFloat16: function getFloat16(byteOffset /* , littleEndian */) { + return unpackFloat16(getUint16(this, byteOffset, arguments.length > 1 ? arguments[1] : false)); + } +}); + + +/***/ }), +/* 228 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aDataView = __webpack_require__(229); +var toIndex = __webpack_require__(216); +// TODO: Replace with module dependency in `core-js@4` +var log2 = __webpack_require__(230); +var roundTiesToEven = __webpack_require__(220); + +var floor = Math.floor; +var pow = Math.pow; + +var MIN_INFINITY16 = 65520; // (2 - 2 ** -11) * 2 ** 15 +var MIN_NORMAL16 = 0.000061005353927612305; // (1 - 2 ** -11) * 2 ** -14 +var REC_MIN_SUBNORMAL16 = 16777216; // 2 ** 10 * 2 ** 14 +var REC_SIGNIFICAND_DENOM16 = 1024; // 2 ** 10; + +var packFloat16 = function (value) { + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return 0x7E00; // NaN + if (value === 0) return (1 / value === -Infinity) << 15; // +0 or -0 + + var neg = value < 0; + if (neg) value = -value; + if (value >= MIN_INFINITY16) return neg << 15 | 0x7C00; // Infinity + if (value < MIN_NORMAL16) return neg << 15 | roundTiesToEven(value * REC_MIN_SUBNORMAL16); // subnormal + + // normal + var exponent = floor(log2(value)); + if (exponent === -15) { + // we round from a value between 2 ** -15 * (1 + 1022/1024) (the largest subnormal) and 2 ** -14 * (1 + 0/1024) (the smallest normal) + // to the latter (former impossible because of the subnormal check above) + return neg << 15 | REC_SIGNIFICAND_DENOM16; + } + var significand = roundTiesToEven((value * pow(2, -exponent) - 1) * REC_SIGNIFICAND_DENOM16); + if (significand === REC_SIGNIFICAND_DENOM16) { + // we round from a value between 2 ** n * (1 + 1023/1024) and 2 ** (n + 1) * (1 + 0/1024) to the latter + return neg << 15 | exponent + 16 << 10; + } + return neg << 15 | exponent + 15 << 10 | significand; +}; + +// eslint-disable-next-line es/no-typed-arrays -- safe +var setUint16 = uncurryThis(DataView.prototype.setUint16); + +// `DataView.prototype.setFloat16` method +// https://tc39.es/ecma262/#sec-dataview.prototype.setfloat16 +$({ target: 'DataView', proto: true }, { + setFloat16: function setFloat16(byteOffset, value /* , littleEndian */) { + setUint16( + aDataView(this), + toIndex(byteOffset), + packFloat16(+value), + arguments.length > 2 ? arguments[2] : false + ); + } +}); + + +/***/ }), +/* 229 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(69); + +var $TypeError = TypeError; + +module.exports = function (argument) { + if (classof(argument) === 'DataView') return argument; + throw new $TypeError('Argument is not a DataView'); +}; + + +/***/ }), +/* 230 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var log = Math.log; +var LN2 = Math.LN2; + +// `Math.log2` method +// https://tc39.es/ecma262/#sec-math.log2 +// eslint-disable-next-line es/no-math-log2 -- safe +module.exports = Math.log2 || function log2(x) { + return log(x) / LN2; +}; + + +/***/ }), +/* 231 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var defineBuiltInAccessor = __webpack_require__(77); +var isDetached = __webpack_require__(232); + +var ArrayBufferPrototype = ArrayBuffer.prototype; + +// `ArrayBuffer.prototype.detached` getter +// https://tc39.es/ecma262/#sec-get-arraybuffer.prototype.detached +if (DESCRIPTORS && !('detached' in ArrayBufferPrototype)) { + defineBuiltInAccessor(ArrayBufferPrototype, 'detached', { + configurable: true, + get: function detached() { + return isDetached(this); + } + }); +} + + +/***/ }), +/* 232 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var NATIVE_ARRAY_BUFFER = __webpack_require__(213); +var arrayBufferByteLength = __webpack_require__(233); + +var DataView = globalThis.DataView; + +module.exports = function (O) { + if (!NATIVE_ARRAY_BUFFER || arrayBufferByteLength(O) !== 0) return false; + try { + // eslint-disable-next-line no-new -- thrower + new DataView(O); + return false; + } catch (error) { + return true; + } +}; + + +/***/ }), +/* 233 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var uncurryThisAccessor = __webpack_require__(119); +var classof = __webpack_require__(15); + +var ArrayBuffer = globalThis.ArrayBuffer; +var TypeError = globalThis.TypeError; + +// Includes +// - Perform ? RequireInternalSlot(O, [[ArrayBufferData]]). +// - If IsSharedArrayBuffer(O) is true, throw a TypeError exception. +module.exports = ArrayBuffer && uncurryThisAccessor(ArrayBuffer.prototype, 'byteLength', 'get') || function (O) { + if (classof(O) !== 'ArrayBuffer') throw new TypeError('ArrayBuffer expected'); + return O.byteLength; +}; + + +/***/ }), +/* 234 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $transfer = __webpack_require__(235); + +// `ArrayBuffer.prototype.transfer` method +// https://tc39.es/ecma262/#sec-arraybuffer.prototype.transfer +if ($transfer) $({ target: 'ArrayBuffer', proto: true }, { + transfer: function transfer() { + return $transfer(this, arguments.length ? arguments[0] : undefined, true); + } +}); + + +/***/ }), +/* 235 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var uncurryThisAccessor = __webpack_require__(119); +var toIndex = __webpack_require__(216); +var notDetached = __webpack_require__(236); +var arrayBufferByteLength = __webpack_require__(233); +var detachTransferable = __webpack_require__(237); +var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(239); + +var structuredClone = globalThis.structuredClone; +var ArrayBuffer = globalThis.ArrayBuffer; +var DataView = globalThis.DataView; +var max = Math.max; +var min = Math.min; +var ArrayBufferPrototype = ArrayBuffer.prototype; +var DataViewPrototype = DataView.prototype; +var slice = uncurryThis(ArrayBufferPrototype.slice); +var isResizable = uncurryThisAccessor(ArrayBufferPrototype, 'resizable', 'get'); +var maxByteLength = uncurryThisAccessor(ArrayBufferPrototype, 'maxByteLength', 'get'); +var getInt8 = uncurryThis(DataViewPrototype.getInt8); +var setInt8 = uncurryThis(DataViewPrototype.setInt8); + +module.exports = (PROPER_STRUCTURED_CLONE_TRANSFER || detachTransferable) && function (arrayBuffer, newLength, preserveResizability) { + var byteLength = arrayBufferByteLength(arrayBuffer); + var newByteLength = newLength === undefined ? byteLength : toIndex(newLength); + var fixedLength = !isResizable || !isResizable(arrayBuffer); + var newBuffer; + notDetached(arrayBuffer); + if (PROPER_STRUCTURED_CLONE_TRANSFER) { + arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] }); + if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer; + } + if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) { + newBuffer = slice(arrayBuffer, 0, newByteLength); + } else { + var options = preserveResizability && !fixedLength && maxByteLength + ? { maxByteLength: max(newByteLength, maxByteLength(arrayBuffer)) } + : undefined; + newBuffer = new ArrayBuffer(newByteLength, options); + var a = new DataView(arrayBuffer); + var b = new DataView(newBuffer); + var copyLength = min(newByteLength, byteLength); + for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i)); + } + if (!PROPER_STRUCTURED_CLONE_TRANSFER) detachTransferable(arrayBuffer); + return newBuffer; +}; + + +/***/ }), +/* 236 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isDetached = __webpack_require__(232); + +var $TypeError = TypeError; + +module.exports = function (it) { + if (isDetached(it)) throw new $TypeError('ArrayBuffer is detached'); + return it; +}; + + +/***/ }), +/* 237 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var getBuiltInNodeModule = __webpack_require__(238); +var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(239); + +var structuredClone = globalThis.structuredClone; +var $ArrayBuffer = globalThis.ArrayBuffer; +var $MessageChannel = globalThis.MessageChannel; +var detach = false; +var WorkerThreads, channel, buffer, $detach; + +if (PROPER_STRUCTURED_CLONE_TRANSFER) { + detach = function (transferable) { + structuredClone(transferable, { transfer: [transferable] }); + }; +} else if ($ArrayBuffer) try { + if (!$MessageChannel) { + WorkerThreads = getBuiltInNodeModule('worker_threads'); + if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel; + } + + if ($MessageChannel) { + channel = new $MessageChannel(); + buffer = new $ArrayBuffer(2); + + $detach = function (transferable) { + channel.port1.postMessage(null, [transferable]); + }; + + if (buffer.byteLength === 2) { + $detach(buffer); + if (buffer.byteLength === 0) detach = $detach; + } + } +} catch (error) { /* empty */ } + +module.exports = detach; + + +/***/ }), +/* 238 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var IS_NODE = __webpack_require__(188); + +module.exports = function (name) { + if (IS_NODE) { + try { + return globalThis.process.getBuiltinModule(name); + } catch (error) { /* empty */ } + try { + // eslint-disable-next-line no-new-func -- safe + return Function('return require("' + name + '")')(); + } catch (error) { /* empty */ } + } +}; + + +/***/ }), +/* 239 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); +var V8 = __webpack_require__(27); +var ENVIRONMENT = __webpack_require__(189); + +var structuredClone = globalThis.structuredClone; + +module.exports = !!structuredClone && !fails(function () { + // prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if ((ENVIRONMENT === 'DENO' && V8 > 92) || (ENVIRONMENT === 'NODE' && V8 > 94) || (ENVIRONMENT === 'BROWSER' && V8 > 97)) return false; + var buffer = new ArrayBuffer(8); + var clone = structuredClone(buffer, { transfer: [buffer] }); + return buffer.byteLength !== 0 || clone.byteLength !== 8; +}); + + +/***/ }), +/* 240 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $transfer = __webpack_require__(235); + +// `ArrayBuffer.prototype.transferToFixedLength` method +// https://tc39.es/ecma262/#sec-arraybuffer.prototype.transfertofixedlength +if ($transfer) $({ target: 'ArrayBuffer', proto: true }, { + transferToFixedLength: function transferToFixedLength() { + return $transfer(this, arguments.length ? arguments[0] : undefined, false); + } +}); + + +/***/ }), +/* 241 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); + +// IE8- non-standard case +var FORCED = fails(function () { + // eslint-disable-next-line es/no-date-prototype-getyear-setyear -- detection + return new Date(16e11).getYear() !== 120; +}); + +var getFullYear = uncurryThis(Date.prototype.getFullYear); + +// `Date.prototype.getYear` method +// https://tc39.es/ecma262/#sec-date.prototype.getyear +$({ target: 'Date', proto: true, forced: FORCED }, { + getYear: function getYear() { + return getFullYear(this) - 1900; + } +}); + + +/***/ }), +/* 242 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); + +var $Date = Date; +var thisTimeValue = uncurryThis($Date.prototype.getTime); + +// `Date.now` method +// https://tc39.es/ecma262/#sec-date.now +$({ target: 'Date', stat: true }, { + now: function now() { + return thisTimeValue(new $Date()); + } +}); + + +/***/ }), +/* 243 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toIntegerOrInfinity = __webpack_require__(61); + +var DatePrototype = Date.prototype; +var thisTimeValue = uncurryThis(DatePrototype.getTime); +var setFullYear = uncurryThis(DatePrototype.setFullYear); + +// `Date.prototype.setYear` method +// https://tc39.es/ecma262/#sec-date.prototype.setyear +$({ target: 'Date', proto: true }, { + setYear: function setYear(year) { + // validate + thisTimeValue(this); + var y = +year; + // eslint-disable-next-line no-self-compare -- NaN check + if (y !== y) return setFullYear(this, y); + var yi = toIntegerOrInfinity(y); + var yyyy = yi >= 0 && yi <= 99 ? yi + 1900 : yi; + return setFullYear(this, yyyy); + } +}); + + +/***/ }), +/* 244 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Date.prototype.toGMTString` method +// https://tc39.es/ecma262/#sec-date.prototype.togmtstring +$({ target: 'Date', proto: true }, { + toGMTString: Date.prototype.toUTCString +}); + + +/***/ }), +/* 245 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toISOString = __webpack_require__(246); + +// `Date.prototype.toISOString` method +// https://tc39.es/ecma262/#sec-date.prototype.toisostring +// PhantomJS / old WebKit has a broken implementations +$({ target: 'Date', proto: true, forced: Date.prototype.toISOString !== toISOString }, { + toISOString: toISOString +}); + + +/***/ }), +/* 246 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var padStart = __webpack_require__(247).start; + +var $RangeError = RangeError; +var $isFinite = isFinite; +var abs = Math.abs; +var DatePrototype = Date.prototype; +var nativeDateToISOString = DatePrototype.toISOString; +var thisTimeValue = uncurryThis(DatePrototype.getTime); +var getUTCDate = uncurryThis(DatePrototype.getUTCDate); +var getUTCFullYear = uncurryThis(DatePrototype.getUTCFullYear); +var getUTCHours = uncurryThis(DatePrototype.getUTCHours); +var getUTCMilliseconds = uncurryThis(DatePrototype.getUTCMilliseconds); +var getUTCMinutes = uncurryThis(DatePrototype.getUTCMinutes); +var getUTCMonth = uncurryThis(DatePrototype.getUTCMonth); +var getUTCSeconds = uncurryThis(DatePrototype.getUTCSeconds); + +// `Date.prototype.toISOString` method implementation +// https://tc39.es/ecma262/#sec-date.prototype.toisostring +// PhantomJS / old WebKit fails here: +module.exports = (fails(function () { + return nativeDateToISOString.call(new Date(-5e13 - 1)) !== '0385-07-25T07:06:39.999Z'; +}) || !fails(function () { + nativeDateToISOString.call(new Date(NaN)); +})) ? function toISOString() { + if (!$isFinite(thisTimeValue(this))) throw new $RangeError('Invalid time value'); + var date = this; + var year = getUTCFullYear(date); + var milliseconds = getUTCMilliseconds(date); + var sign = year < 0 ? '-' : year > 9999 ? '+' : ''; + return sign + padStart(abs(year), sign ? 6 : 4, 0) + + '-' + padStart(getUTCMonth(date) + 1, 2, 0) + + '-' + padStart(getUTCDate(date), 2, 0) + + 'T' + padStart(getUTCHours(date), 2, 0) + + ':' + padStart(getUTCMinutes(date), 2, 0) + + ':' + padStart(getUTCSeconds(date), 2, 0) + + '.' + padStart(milliseconds, 3, 0) + + 'Z'; +} : nativeDateToISOString; + + +/***/ }), +/* 247 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var $repeat = __webpack_require__(248); +var requireObjectCoercible = __webpack_require__(16); + +var repeat = uncurryThis($repeat); +var stringSlice = uncurryThis(''.slice); +var ceil = Math.ceil; + +// `String.prototype.{ padStart, padEnd }` methods implementation +var createMethod = function (IS_END) { + return function ($this, maxLength, fillString) { + var S = toString(requireObjectCoercible($this)); + var intMaxLength = toLength(maxLength); + var stringLength = S.length; + if (intMaxLength <= stringLength) return S; + var fillStr = fillString === undefined ? ' ' : toString(fillString); + var fillLen, stringFiller; + if (fillStr === '') return S; + fillLen = intMaxLength - stringLength; + stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length)); + if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen); + return IS_END ? S + stringFiller : stringFiller + S; + }; +}; + +module.exports = { + // `String.prototype.padStart` method + // https://tc39.es/ecma262/#sec-string.prototype.padstart + start: createMethod(false), + // `String.prototype.padEnd` method + // https://tc39.es/ecma262/#sec-string.prototype.padend + end: createMethod(true) +}; + + +/***/ }), +/* 248 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(61); +var toString = __webpack_require__(68); +var requireObjectCoercible = __webpack_require__(16); + +var $RangeError = RangeError; +var floor = Math.floor; + +// `String.prototype.repeat` method implementation +// https://tc39.es/ecma262/#sec-string.prototype.repeat +module.exports = function repeat(count) { + var str = toString(requireObjectCoercible(this)); + var result = ''; + var n = toIntegerOrInfinity(count); + if (n < 0 || n === Infinity) throw new $RangeError('Wrong number of repetitions'); + for (;n > 0; (n = floor(n / 2)) && (str += str)) if (n % 2) result += str; + return result; +}; + + +/***/ }), +/* 249 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var toObject = __webpack_require__(39); +var toPrimitive = __webpack_require__(19); + +var FORCED = fails(function () { + return new Date(NaN).toJSON() !== null + || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1; +}); + +// `Date.prototype.toJSON` method +// https://tc39.es/ecma262/#sec-date.prototype.tojson +$({ target: 'Date', proto: true, arity: 1, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + toJSON: function toJSON(key) { + var O = toObject(this); + var pv = toPrimitive(O, 'number'); + return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString(); + } +}); + + +/***/ }), +/* 250 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(38); +var defineBuiltIn = __webpack_require__(47); +var dateToPrimitive = __webpack_require__(251); +var wellKnownSymbol = __webpack_require__(33); + +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var DatePrototype = Date.prototype; + +// `Date.prototype[@@toPrimitive]` method +// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive +if (!hasOwn(DatePrototype, TO_PRIMITIVE)) { + defineBuiltIn(DatePrototype, TO_PRIMITIVE, dateToPrimitive); +} + + +/***/ }), +/* 251 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); +var ordinaryToPrimitive = __webpack_require__(32); + +var $TypeError = TypeError; + +// `Date.prototype[@@toPrimitive](hint)` method implementation +// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive +module.exports = function (hint) { + anObject(this); + if (hint === 'string' || hint === 'default') hint = 'string'; + else if (hint !== 'number') throw new $TypeError('Incorrect hint'); + return ordinaryToPrimitive(this, hint); +}; + + +/***/ }), +/* 252 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var uncurryThis = __webpack_require__(14); +var defineBuiltIn = __webpack_require__(47); + +var DatePrototype = Date.prototype; +var INVALID_DATE = 'Invalid Date'; +var TO_STRING = 'toString'; +var nativeDateToString = uncurryThis(DatePrototype[TO_STRING]); +var thisTimeValue = uncurryThis(DatePrototype.getTime); + +// `Date.prototype.toString` method +// https://tc39.es/ecma262/#sec-date.prototype.tostring +if (String(new Date(NaN)) !== INVALID_DATE) { + defineBuiltIn(DatePrototype, TO_STRING, function toString() { + var value = thisTimeValue(this); + // eslint-disable-next-line no-self-compare -- NaN check + return value === value ? nativeDateToString(this) : INVALID_DATE; + }); +} + + +/***/ }), +/* 253 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-explicit-resource-management +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var getBuiltIn = __webpack_require__(23); +var aCallable = __webpack_require__(30); +var anInstance = __webpack_require__(215); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltIns = __webpack_require__(214); +var defineBuiltInAccessor = __webpack_require__(77); +var wellKnownSymbol = __webpack_require__(33); +var InternalStateModule = __webpack_require__(51); +var addDisposableResource = __webpack_require__(254); + +var SuppressedError = getBuiltIn('SuppressedError'); +var $ReferenceError = ReferenceError; + +var DISPOSE = wellKnownSymbol('dispose'); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +var DISPOSABLE_STACK = 'DisposableStack'; +var setInternalState = InternalStateModule.set; +var getDisposableStackInternalState = InternalStateModule.getterFor(DISPOSABLE_STACK); + +var HINT = 'sync-dispose'; +var DISPOSED = 'disposed'; +var PENDING = 'pending'; + +var getPendingDisposableStackInternalState = function (stack) { + var internalState = getDisposableStackInternalState(stack); + if (internalState.state === DISPOSED) throw new $ReferenceError(DISPOSABLE_STACK + ' already disposed'); + return internalState; +}; + +var $DisposableStack = function DisposableStack() { + setInternalState(anInstance(this, DisposableStackPrototype), { + type: DISPOSABLE_STACK, + state: PENDING, + stack: [] + }); + + if (!DESCRIPTORS) this.disposed = false; +}; + +var DisposableStackPrototype = $DisposableStack.prototype; + +defineBuiltIns(DisposableStackPrototype, { + dispose: function dispose() { + var internalState = getDisposableStackInternalState(this); + if (internalState.state === DISPOSED) return; + internalState.state = DISPOSED; + if (!DESCRIPTORS) this.disposed = true; + var stack = internalState.stack; + var i = stack.length; + var thrown = false; + var suppressed; + while (i) { + var disposeMethod = stack[--i]; + stack[i] = null; + try { + disposeMethod(); + } catch (errorResult) { + if (thrown) { + suppressed = new SuppressedError(errorResult, suppressed); + } else { + thrown = true; + suppressed = errorResult; + } + } + } + internalState.stack = null; + if (thrown) throw suppressed; + }, + use: function use(value) { + addDisposableResource(getPendingDisposableStackInternalState(this), value, HINT); + return value; + }, + adopt: function adopt(value, onDispose) { + var internalState = getPendingDisposableStackInternalState(this); + aCallable(onDispose); + addDisposableResource(internalState, undefined, HINT, function () { + onDispose(value); + }); + return value; + }, + defer: function defer(onDispose) { + var internalState = getPendingDisposableStackInternalState(this); + aCallable(onDispose); + addDisposableResource(internalState, undefined, HINT, onDispose); + }, + move: function move() { + var internalState = getPendingDisposableStackInternalState(this); + var newDisposableStack = new $DisposableStack(); + getDisposableStackInternalState(newDisposableStack).stack = internalState.stack; + internalState.stack = []; + internalState.state = DISPOSED; + if (!DESCRIPTORS) this.disposed = true; + return newDisposableStack; + } +}); + +if (DESCRIPTORS) defineBuiltInAccessor(DisposableStackPrototype, 'disposed', { + configurable: true, + get: function disposed() { + return getDisposableStackInternalState(this).state === DISPOSED; + } +}); + +defineBuiltIn(DisposableStackPrototype, DISPOSE, DisposableStackPrototype.dispose, { name: 'dispose' }); +defineBuiltIn(DisposableStackPrototype, TO_STRING_TAG, DISPOSABLE_STACK, { nonWritable: true }); + +$({ global: true, constructor: true }, { + DisposableStack: $DisposableStack +}); + + +/***/ }), +/* 254 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var bind = __webpack_require__(84); +var anObject = __webpack_require__(46); +var aCallable = __webpack_require__(30); +var isNullOrUndefined = __webpack_require__(17); +var getMethod = __webpack_require__(29); +var wellKnownSymbol = __webpack_require__(33); + +var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose'); +var DISPOSE = wellKnownSymbol('dispose'); + +var push = uncurryThis([].push); + +// `GetDisposeMethod` abstract operation +// https://tc39.es/proposal-explicit-resource-management/#sec-getdisposemethod +var getDisposeMethod = function (V, hint) { + if (hint === 'async-dispose') { + var method = getMethod(V, ASYNC_DISPOSE); + if (method !== undefined) return method; + method = getMethod(V, DISPOSE); + if (method === undefined) return method; + return function () { + var O = this; + var Promise = getBuiltIn('Promise'); + return new Promise(function (resolve) { + call(method, O); + resolve(undefined); + }); + }; + } return getMethod(V, DISPOSE); +}; + +// `CreateDisposableResource` abstract operation +// https://tc39.es/proposal-explicit-resource-management/#sec-createdisposableresource +var createDisposableResource = function (V, hint, method) { + if (arguments.length < 3 && !isNullOrUndefined(V)) { + method = aCallable(getDisposeMethod(anObject(V), hint)); + } + + return method === undefined ? function () { + return undefined; + } : bind(method, V); +}; + +// `AddDisposableResource` abstract operation +// https://tc39.es/proposal-explicit-resource-management/#sec-adddisposableresource +module.exports = function (disposable, V, hint, method) { + var resource; + if (arguments.length < 4) { + // When `V`` is either `null` or `undefined` and hint is `async-dispose`, + // we record that the resource was evaluated to ensure we will still perform an `Await` when resources are later disposed. + if (isNullOrUndefined(V) && hint === 'sync-dispose') return; + resource = createDisposableResource(V, hint); + } else { + resource = createDisposableResource(undefined, hint, method); + } + + push(disposable.stack, resource); +}; + + +/***/ }), +/* 255 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); + +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var exec = uncurryThis(/./.exec); +var numberToString = uncurryThis(1.1.toString); +var toUpperCase = uncurryThis(''.toUpperCase); + +var raw = /[\w*+\-./@]/; + +var hex = function (code, length) { + var result = numberToString(code, 16); + while (result.length < length) result = '0' + result; + return result; +}; + +// `escape` method +// https://tc39.es/ecma262/#sec-escape-string +$({ global: true }, { + escape: function escape(string) { + var str = toString(string); + var result = ''; + var length = str.length; + var index = 0; + var chr, code; + while (index < length) { + chr = charAt(str, index++); + if (exec(raw, chr)) { + result += chr; + } else { + code = charCodeAt(chr, 0); + if (code < 256) { + result += '%' + toUpperCase(hex(code, 2)); + } else { + result += '%u' + toUpperCase(hex(code, 4)); + } + } + } return result; + } +}); + + +/***/ }), +/* 256 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var bind = __webpack_require__(257); + +// `Function.prototype.bind` method +// https://tc39.es/ecma262/#sec-function.prototype.bind +// eslint-disable-next-line es/no-function-prototype-bind -- detection +$({ target: 'Function', proto: true, forced: Function.bind !== bind }, { + bind: bind +}); + + +/***/ }), +/* 257 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); +var isObject = __webpack_require__(20); +var hasOwn = __webpack_require__(38); +var arraySlice = __webpack_require__(76); +var NATIVE_BIND = __webpack_require__(9); + +var $Function = Function; +var concat = uncurryThis([].concat); +var join = uncurryThis([].join); +var factories = {}; + +var construct = function (C, argsLength, args) { + if (!hasOwn(factories, argsLength)) { + var list = []; + var i = 0; + for (; i < argsLength; i++) list[i] = 'a[' + i + ']'; + factories[argsLength] = $Function('C,a', 'return new C(' + join(list, ',') + ')'); + } return factories[argsLength](C, args); +}; + +// `Function.prototype.bind` method implementation +// https://tc39.es/ecma262/#sec-function.prototype.bind +// eslint-disable-next-line es/no-function-prototype-bind -- detection +module.exports = NATIVE_BIND ? $Function.bind : function bind(that /* , ...args */) { + var F = aCallable(this); + var Prototype = F.prototype; + var partArgs = arraySlice(arguments, 1); + var boundFunction = function bound(/* args... */) { + var args = concat(partArgs, arraySlice(arguments)); + return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args); + }; + if (isObject(Prototype)) boundFunction.prototype = Prototype; + return boundFunction; +}; + + +/***/ }), +/* 258 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var definePropertyModule = __webpack_require__(44); +var isPrototypeOf = __webpack_require__(24); +var wellKnownSymbol = __webpack_require__(33); +var makeBuiltIn = __webpack_require__(48); + +var HAS_INSTANCE = wellKnownSymbol('hasInstance'); +var FunctionPrototype = Function.prototype; + +// `Function.prototype[@@hasInstance]` method +// https://tc39.es/ecma262/#sec-function.prototype-@@hasinstance +if (!(HAS_INSTANCE in FunctionPrototype)) { + definePropertyModule.f(FunctionPrototype, HAS_INSTANCE, { value: makeBuiltIn(function (O) { + if (!isCallable(this) || !isObject(O)) return false; + var P = this.prototype; + return isObject(P) ? isPrototypeOf(P, O) : O instanceof this; + }, HAS_INSTANCE) }); +} + + +/***/ }), +/* 259 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var FUNCTION_NAME_EXISTS = __webpack_require__(49).EXISTS; +var uncurryThis = __webpack_require__(14); +var defineBuiltInAccessor = __webpack_require__(77); + +var FunctionPrototype = Function.prototype; +var functionToString = uncurryThis(FunctionPrototype.toString); +var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; +var regExpExec = uncurryThis(nameRE.exec); +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (DESCRIPTORS && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); +} + + +/***/ }), +/* 260 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); + +// `globalThis` object +// https://tc39.es/ecma262/#sec-globalthis +$({ global: true, forced: globalThis.globalThis !== globalThis }, { + globalThis: globalThis +}); + + +/***/ }), +/* 261 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var anInstance = __webpack_require__(215); +var anObject = __webpack_require__(46); +var isCallable = __webpack_require__(21); +var getPrototypeOf = __webpack_require__(134); +var defineBuiltInAccessor = __webpack_require__(77); +var createProperty = __webpack_require__(90); +var fails = __webpack_require__(7); +var hasOwn = __webpack_require__(38); +var wellKnownSymbol = __webpack_require__(33); +var IteratorPrototype = __webpack_require__(178).IteratorPrototype; +var DESCRIPTORS = __webpack_require__(6); +var IS_PURE = __webpack_require__(36); + +var CONSTRUCTOR = 'constructor'; +var ITERATOR = 'Iterator'; +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +var $TypeError = TypeError; +var NativeIterator = globalThis[ITERATOR]; + +// FF56- have non-standard global helper `Iterator` +var FORCED = IS_PURE + || !isCallable(NativeIterator) + || NativeIterator.prototype !== IteratorPrototype + // FF44- non-standard `Iterator` passes previous tests + || !fails(function () { NativeIterator({}); }); + +var IteratorConstructor = function Iterator() { + anInstance(this, IteratorPrototype); + if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError('Abstract class Iterator not directly constructable'); +}; + +var defineIteratorPrototypeAccessor = function (key, value) { + if (DESCRIPTORS) { + defineBuiltInAccessor(IteratorPrototype, key, { + configurable: true, + get: function () { + return value; + }, + set: function (replacement) { + anObject(this); + if (this === IteratorPrototype) throw new $TypeError("You can't redefine this property"); + if (hasOwn(this, key)) this[key] = replacement; + else createProperty(this, key, replacement); + } + }); + } else IteratorPrototype[key] = value; +}; + +if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR); + +if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) { + defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor); +} + +IteratorConstructor.prototype = IteratorPrototype; + +// `Iterator` constructor +// https://tc39.es/ecma262/#sec-iterator +$({ global: true, constructor: true, forced: FORCED }, { + Iterator: IteratorConstructor +}); + + +/***/ }), +/* 262 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorMethod = __webpack_require__(140); +var createIteratorProxy = __webpack_require__(263); +var IS_PURE = __webpack_require__(36); + +var $Array = Array; + +var IteratorProxy = createIteratorProxy(function () { + while (true) { + var iterator = this.iterator; + if (!iterator) { + var iterableIndex = this.nextIterableIndex++; + var iterables = this.iterables; + if (iterableIndex >= iterables.length) { + this.done = true; + return; + } + var entry = iterables[iterableIndex]; + this.iterables[iterableIndex] = null; + iterator = this.iterator = anObject(call(entry.method, entry.iterable)); + this.next = iterator.next; + } + var result = anObject(call(this.next, iterator)); + if (result.done) { + this.iterator = null; + this.next = null; + continue; + } + return result.value; + } +}); + +// `Iterator.concat` method +// https://tc39.es/ecma262/#sec-iterator.concat +$({ target: 'Iterator', stat: true, forced: IS_PURE }, { + concat: function concat() { + var length = arguments.length; + var iterables = $Array(length); + for (var index = 0; index < length; index++) { + var item = anObject(arguments[index]); + iterables[index] = { + iterable: item, + method: aCallable(getIteratorMethod(item)) + }; + } + return new IteratorProxy({ + iterables: iterables, + nextIterableIndex: 0, + iterator: null, + next: null + }); + } +}); + + +/***/ }), +/* 263 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var create = __webpack_require__(71); +var createNonEnumerableProperty = __webpack_require__(43); +var defineBuiltIns = __webpack_require__(214); +var wellKnownSymbol = __webpack_require__(33); +var InternalStateModule = __webpack_require__(51); +var getMethod = __webpack_require__(29); +var IteratorPrototype = __webpack_require__(178).IteratorPrototype; +var createIterResultObject = __webpack_require__(179); +var iteratorClose = __webpack_require__(141); +var iteratorCloseAll = __webpack_require__(264); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var ITERATOR_HELPER = 'IteratorHelper'; +var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator'; +var NORMAL = 'normal'; +var THROW = 'throw'; +var setInternalState = InternalStateModule.set; + +var createIteratorProxyPrototype = function (IS_ITERATOR) { + var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER); + + return defineBuiltIns(create(IteratorPrototype), { + next: function next() { + var state = getInternalState(this); + // for simplification: + // for `%WrapForValidIteratorPrototype%.next` or with `state.returnHandlerResult` our `nextHandler` returns `IterResultObject` + // for `%IteratorHelperPrototype%.next` - just a value + if (IS_ITERATOR) return state.nextHandler(); + if (state.done) return createIterResultObject(undefined, true); + try { + var result = state.nextHandler(); + return state.returnHandlerResult ? result : createIterResultObject(result, state.done); + } catch (error) { + state.done = true; + throw error; + } + }, + 'return': function () { + var state = getInternalState(this); + var iterator = state.iterator; + var done = state.done; + state.done = true; + if (IS_ITERATOR) { + var returnMethod = getMethod(iterator, 'return'); + return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true); + } + if (done) return createIterResultObject(undefined, true); + if (state.inner) try { + iteratorClose(state.inner.iterator, NORMAL); + } catch (error) { + return iteratorClose(iterator, THROW, error); + } + if (state.openIters) try { + iteratorCloseAll(state.openIters, NORMAL); + } catch (error) { + if (iterator) return iteratorClose(iterator, THROW, error); + throw error; + } + if (iterator) iteratorClose(iterator, NORMAL); + return createIterResultObject(undefined, true); + } + }); +}; + +var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true); +var IteratorHelperPrototype = createIteratorProxyPrototype(false); + +createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper'); + +module.exports = function (nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) { + var IteratorProxy = function Iterator(record, state) { + if (state) { + state.iterator = record.iterator; + state.next = record.next; + } else state = record; + state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER; + state.returnHandlerResult = !!RETURN_HANDLER_RESULT; + state.nextHandler = nextHandler; + state.counter = 0; + state.done = false; + setInternalState(this, state); + }; + + IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype; + + return IteratorProxy; +}; + + +/***/ }), +/* 264 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var iteratorClose = __webpack_require__(141); + +module.exports = function (iters, kind, value) { + for (var i = iters.length - 1; i >= 0; i--) { + if (iters[i] === undefined) continue; + try { + value = iteratorClose(iters[i].iterator, kind, value); + } catch (error) { + kind = 'throw'; + value = error; + } + } + if (kind === 'throw') throw value; + return value; +}; + + +/***/ }), +/* 265 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-explicit-resource-management +var call = __webpack_require__(8); +var defineBuiltIn = __webpack_require__(47); +var getMethod = __webpack_require__(29); +var hasOwn = __webpack_require__(38); +var wellKnownSymbol = __webpack_require__(33); +var IteratorPrototype = __webpack_require__(178).IteratorPrototype; + +var DISPOSE = wellKnownSymbol('dispose'); + +if (!hasOwn(IteratorPrototype, DISPOSE)) { + defineBuiltIn(IteratorPrototype, DISPOSE, function () { + var $return = getMethod(this, 'return'); + if ($return) call($return, this); + }); +} + + +/***/ }), +/* 266 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var notANaN = __webpack_require__(268); +var toPositiveInteger = __webpack_require__(269); +var iteratorClose = __webpack_require__(141); +var createIteratorProxy = __webpack_require__(263); +var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(270); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); +var IS_PURE = __webpack_require__(36); + +var DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('drop', 0); +var dropWithoutClosingOnEarlyError = !IS_PURE && !DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR + && iteratorHelperWithoutClosingOnEarlyError('drop', RangeError); + +var FORCED = IS_PURE || DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR || dropWithoutClosingOnEarlyError; + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + var next = this.next; + var result, done; + while (this.remaining) { + this.remaining--; + result = anObject(call(next, iterator)); + done = this.done = !!result.done; + if (done) return; + } + result = anObject(call(next, iterator)); + done = this.done = !!result.done; + if (!done) return result.value; +}); + +// `Iterator.prototype.drop` method +// https://tc39.es/ecma262/#sec-iterator.prototype.drop +$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, { + drop: function drop(limit) { + anObject(this); + var remaining; + try { + remaining = toPositiveInteger(notANaN(+limit)); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (dropWithoutClosingOnEarlyError) return call(dropWithoutClosingOnEarlyError, this, remaining); + + return new IteratorProxy(getIteratorDirect(this), { + remaining: remaining + }); + } +}); + + +/***/ }), +/* 267 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// `GetIteratorDirect(obj)` abstract operation +// https://tc39.es/ecma262/#sec-getiteratordirect +module.exports = function (obj) { + return { + iterator: obj, + next: obj.next, + done: false + }; +}; + + +/***/ }), +/* 268 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $RangeError = RangeError; + +module.exports = function (it) { + // eslint-disable-next-line no-self-compare -- NaN check + if (it === it) return it; + throw new $RangeError('NaN is not allowed'); +}; + + +/***/ }), +/* 269 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(61); + +var $RangeError = RangeError; + +module.exports = function (it) { + var result = toIntegerOrInfinity(it); + if (result < 0) throw new $RangeError("The argument can't be less than 0"); + return result; +}; + + +/***/ }), +/* 270 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// Should throw an error on invalid iterator +// https://issues.chromium.org/issues/336839115 +module.exports = function (methodName, argument) { + // eslint-disable-next-line es/no-iterator -- required for testing + var method = typeof Iterator == 'function' && Iterator.prototype[methodName]; + if (method) try { + method.call({ next: null }, argument).next(); + } catch (error) { + return true; + } +}; + + +/***/ }), +/* 271 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +// https://github.com/tc39/ecma262/pull/3467 +module.exports = function (METHOD_NAME, ExpectedError) { + var Iterator = globalThis.Iterator; + var IteratorPrototype = Iterator && Iterator.prototype; + var method = IteratorPrototype && IteratorPrototype[METHOD_NAME]; + + var CLOSED = false; + + if (method) try { + method.call({ + next: function () { return { done: true }; }, + 'return': function () { CLOSED = true; } + }, -1); + } catch (error) { + // https://bugs.webkit.org/show_bug.cgi?id=291195 + if (!(error instanceof ExpectedError)) CLOSED = false; + } + + if (!CLOSED) return method; +}; + + +/***/ }), +/* 272 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var iterate = __webpack_require__(136); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); + +var everyWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('every', TypeError); + +// `Iterator.prototype.every` method +// https://tc39.es/ecma262/#sec-iterator.prototype.every +$({ target: 'Iterator', proto: true, real: true, forced: everyWithoutClosingOnEarlyError }, { + every: function every(predicate) { + anObject(this); + try { + aCallable(predicate); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (everyWithoutClosingOnEarlyError) return call(everyWithoutClosingOnEarlyError, this, predicate); + + var record = getIteratorDirect(this); + var counter = 0; + return !iterate(record, function (value, stop) { + if (!predicate(value, counter++)) return stop(); + }, { IS_RECORD: true, INTERRUPTED: true }).stopped; + } +}); + + +/***/ }), +/* 273 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var createIteratorProxy = __webpack_require__(263); +var callWithSafeIterationClosing = __webpack_require__(170); +var IS_PURE = __webpack_require__(36); +var iteratorClose = __webpack_require__(141); +var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(270); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); + +var FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('filter', function () { /* empty */ }); +var filterWithoutClosingOnEarlyError = !IS_PURE && !FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR + && iteratorHelperWithoutClosingOnEarlyError('filter', TypeError); + +var FORCED = IS_PURE || FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR || filterWithoutClosingOnEarlyError; + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + var predicate = this.predicate; + var next = this.next; + var result, done, value; + while (true) { + result = anObject(call(next, iterator)); + done = this.done = !!result.done; + if (done) return; + value = result.value; + if (callWithSafeIterationClosing(iterator, predicate, [value, this.counter++], true)) return value; + } +}); + +// `Iterator.prototype.filter` method +// https://tc39.es/ecma262/#sec-iterator.prototype.filter +$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, { + filter: function filter(predicate) { + anObject(this); + try { + aCallable(predicate); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (filterWithoutClosingOnEarlyError) return call(filterWithoutClosingOnEarlyError, this, predicate); + + return new IteratorProxy(getIteratorDirect(this), { + predicate: predicate + }); + } +}); + + +/***/ }), +/* 274 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var iterate = __webpack_require__(136); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); + +var findWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('find', TypeError); + +// `Iterator.prototype.find` method +// https://tc39.es/ecma262/#sec-iterator.prototype.find +$({ target: 'Iterator', proto: true, real: true, forced: findWithoutClosingOnEarlyError }, { + find: function find(predicate) { + anObject(this); + try { + aCallable(predicate); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (findWithoutClosingOnEarlyError) return call(findWithoutClosingOnEarlyError, this, predicate); + + var record = getIteratorDirect(this); + var counter = 0; + return iterate(record, function (value, stop) { + if (predicate(value, counter++)) return stop(value); + }, { IS_RECORD: true, INTERRUPTED: true }).result; + } +}); + + +/***/ }), +/* 275 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var getIteratorFlattenable = __webpack_require__(276); +var createIteratorProxy = __webpack_require__(263); +var iteratorClose = __webpack_require__(141); +var IS_PURE = __webpack_require__(36); +var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(270); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); + +// Should not throw an error for an iterator without `return` method. Fixed in Safari 26.2 +// https://bugs.webkit.org/show_bug.cgi?id=297532 +function throwsOnIteratorWithoutReturn() { + try { + // eslint-disable-next-line es/no-map, es/no-iterator, es/no-iterator-prototype-flatmap -- required for testing + var it = Iterator.prototype.flatMap.call(new Map([[4, 5]]).entries(), function (v) { return v; }); + it.next(); + it['return'](); + } catch (error) { + return true; + } +} + +var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE + && !iteratorHelperThrowsOnInvalidIterator('flatMap', function () { /* empty */ }); +var flatMapWithoutClosingOnEarlyError = !IS_PURE && !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR + && iteratorHelperWithoutClosingOnEarlyError('flatMap', TypeError); + +var FORCED = IS_PURE || FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || flatMapWithoutClosingOnEarlyError + || throwsOnIteratorWithoutReturn(); + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + var mapper = this.mapper; + var result, inner; + + while (true) { + if (inner = this.inner) try { + result = anObject(call(inner.next, inner.iterator)); + if (!result.done) return result.value; + this.inner = null; + } catch (error) { iteratorClose(iterator, 'throw', error); } + + result = anObject(call(this.next, iterator)); + + if (this.done = !!result.done) return; + + try { + this.inner = getIteratorFlattenable(mapper(result.value, this.counter++), false); + } catch (error) { iteratorClose(iterator, 'throw', error); } + } +}); + +// `Iterator.prototype.flatMap` method +// https://tc39.es/ecma262/#sec-iterator.prototype.flatmap +$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, { + flatMap: function flatMap(mapper) { + anObject(this); + try { + aCallable(mapper); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (flatMapWithoutClosingOnEarlyError) return call(flatMapWithoutClosingOnEarlyError, this, mapper); + + return new IteratorProxy(getIteratorDirect(this), { + mapper: mapper, + inner: null + }); + } +}); + + +/***/ }), +/* 276 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var getIteratorMethod = __webpack_require__(140); + +module.exports = function (obj, stringHandling) { + if (!stringHandling || typeof obj !== 'string') anObject(obj); + var method = getIteratorMethod(obj); + return getIteratorDirect(anObject(method !== undefined ? call(method, obj) : obj)); +}; + + +/***/ }), +/* 277 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var iterate = __webpack_require__(136); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); + +var forEachWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('forEach', TypeError); + +// `Iterator.prototype.forEach` method +// https://tc39.es/ecma262/#sec-iterator.prototype.foreach +$({ target: 'Iterator', proto: true, real: true, forced: forEachWithoutClosingOnEarlyError }, { + forEach: function forEach(fn) { + anObject(this); + try { + aCallable(fn); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (forEachWithoutClosingOnEarlyError) return call(forEachWithoutClosingOnEarlyError, this, fn); + + var record = getIteratorDirect(this); + var counter = 0; + iterate(record, function (value) { + fn(value, counter++); + }, { IS_RECORD: true }); + } +}); + + +/***/ }), +/* 278 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toObject = __webpack_require__(39); +var isPrototypeOf = __webpack_require__(24); +var IteratorPrototype = __webpack_require__(178).IteratorPrototype; +var createIteratorProxy = __webpack_require__(263); +var getIteratorFlattenable = __webpack_require__(276); +var IS_PURE = __webpack_require__(36); + +var FORCED = IS_PURE || function () { + // Should not throw when an underlying iterator's `return` method is null + // https://bugs.webkit.org/show_bug.cgi?id=288714 + try { + // eslint-disable-next-line es/no-iterator -- required for testing + Iterator.from({ 'return': null })['return'](); + } catch (error) { + return true; + } +}(); + +var IteratorProxy = createIteratorProxy(function () { + return call(this.next, this.iterator); +}, true); + +// `Iterator.from` method +// https://tc39.es/ecma262/#sec-iterator.from +$({ target: 'Iterator', stat: true, forced: FORCED }, { + from: function from(O) { + var iteratorRecord = getIteratorFlattenable(typeof O == 'string' ? toObject(O) : O, true); + return isPrototypeOf(IteratorPrototype, iteratorRecord.iterator) + ? iteratorRecord.iterator + : new IteratorProxy(iteratorRecord); + } +}); + + +/***/ }), +/* 279 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var createIteratorProxy = __webpack_require__(263); +var callWithSafeIterationClosing = __webpack_require__(170); +var iteratorClose = __webpack_require__(141); +var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(270); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); +var IS_PURE = __webpack_require__(36); + +var MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('map', function () { /* empty */ }); +var mapWithoutClosingOnEarlyError = !IS_PURE && !MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR + && iteratorHelperWithoutClosingOnEarlyError('map', TypeError); + +var FORCED = IS_PURE || MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || mapWithoutClosingOnEarlyError; + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + var result = anObject(call(this.next, iterator)); + var done = this.done = !!result.done; + if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true); +}); + +// `Iterator.prototype.map` method +// https://tc39.es/ecma262/#sec-iterator.prototype.map +$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, { + map: function map(mapper) { + anObject(this); + try { + aCallable(mapper); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (mapWithoutClosingOnEarlyError) return call(mapWithoutClosingOnEarlyError, this, mapper); + + return new IteratorProxy(getIteratorDirect(this), { + mapper: mapper + }); + } +}); + + +/***/ }), +/* 280 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var iterate = __webpack_require__(136); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); +var apply = __webpack_require__(95); +var fails = __webpack_require__(7); + +var $TypeError = TypeError; + +// https://bugs.webkit.org/show_bug.cgi?id=291651 +var FAILS_ON_INITIAL_UNDEFINED = fails(function () { + // eslint-disable-next-line es/no-iterator-prototype-reduce, es/no-array-prototype-keys, array-callback-return -- required for testing + [].keys().reduce(function () { /* empty */ }, undefined); +}); + +var reduceWithoutClosingOnEarlyError = !FAILS_ON_INITIAL_UNDEFINED && iteratorHelperWithoutClosingOnEarlyError('reduce', $TypeError); + +// `Iterator.prototype.reduce` method +// https://tc39.es/ecma262/#sec-iterator.prototype.reduce +$({ target: 'Iterator', proto: true, real: true, forced: FAILS_ON_INITIAL_UNDEFINED || reduceWithoutClosingOnEarlyError }, { + reduce: function reduce(reducer /* , initialValue */) { + anObject(this); + try { + aCallable(reducer); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + var noInitial = arguments.length < 2; + var accumulator = noInitial ? undefined : arguments[1]; + if (reduceWithoutClosingOnEarlyError) { + return apply(reduceWithoutClosingOnEarlyError, this, noInitial ? [reducer] : [reducer, accumulator]); + } + var record = getIteratorDirect(this); + var counter = 0; + iterate(record, function (value) { + if (noInitial) { + noInitial = false; + accumulator = value; + } else { + accumulator = reducer(accumulator, value, counter); + } + counter++; + }, { IS_RECORD: true }); + if (noInitial) throw new $TypeError('Reduce of empty iterator with no initial value'); + return accumulator; + } +}); + + +/***/ }), +/* 281 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var iterate = __webpack_require__(136); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); + +var someWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('some', TypeError); + +// `Iterator.prototype.some` method +// https://tc39.es/ecma262/#sec-iterator.prototype.some +$({ target: 'Iterator', proto: true, real: true, forced: someWithoutClosingOnEarlyError }, { + some: function some(predicate) { + anObject(this); + try { + aCallable(predicate); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (someWithoutClosingOnEarlyError) return call(someWithoutClosingOnEarlyError, this, predicate); + + var record = getIteratorDirect(this); + var counter = 0; + return iterate(record, function (value, stop) { + if (predicate(value, counter++)) return stop(); + }, { IS_RECORD: true, INTERRUPTED: true }).stopped; + } +}); + + +/***/ }), +/* 282 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var notANaN = __webpack_require__(268); +var toPositiveInteger = __webpack_require__(269); +var createIteratorProxy = __webpack_require__(263); +var iteratorClose = __webpack_require__(141); +var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(270); +var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(271); +var IS_PURE = __webpack_require__(36); + +var TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('take', 1); +var takeWithoutClosingOnEarlyError = !IS_PURE && !TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR + && iteratorHelperWithoutClosingOnEarlyError('take', RangeError); + +var FORCED = IS_PURE || TAKE_WITHOUT_THROWING_ON_INVALID_ITERATOR || takeWithoutClosingOnEarlyError; + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + if (!this.remaining--) { + this.done = true; + return iteratorClose(iterator, 'normal', undefined); + } + var result = anObject(call(this.next, iterator)); + var done = this.done = !!result.done; + if (!done) return result.value; +}); + +// `Iterator.prototype.take` method +// https://tc39.es/ecma262/#sec-iterator.prototype.take +$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, { + take: function take(limit) { + anObject(this); + var remaining; + try { + remaining = toPositiveInteger(notANaN(+limit)); + } catch (error) { + iteratorClose(this, 'throw', error); + } + + if (takeWithoutClosingOnEarlyError) return call(takeWithoutClosingOnEarlyError, this, remaining); + + return new IteratorProxy(getIteratorDirect(this), { + remaining: remaining + }); + } +}); + + +/***/ }), +/* 283 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var createProperty = __webpack_require__(90); +var iterate = __webpack_require__(136); +var getIteratorDirect = __webpack_require__(267); + +// `Iterator.prototype.toArray` method +// https://tc39.es/ecma262/#sec-iterator.prototype.toarray +$({ target: 'Iterator', proto: true, real: true }, { + toArray: function toArray() { + var result = []; + var index = 0; + iterate(getIteratorDirect(anObject(this)), function (element) { + createProperty(result, index++, element); + }, { IS_RECORD: true }); + return result; + } +}); + + +/***/ }), +/* 284 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var NATIVE_RAW_JSON = __webpack_require__(98); +var isRawJSON = __webpack_require__(96); + +// `JSON.isRawJSON` method +// https://tc39.es/proposal-json-parse-with-source/#sec-json.israwjson +// https://github.com/tc39/proposal-json-parse-with-source +$({ target: 'JSON', stat: true, forced: !NATIVE_RAW_JSON }, { + isRawJSON: isRawJSON +}); + + +/***/ }), +/* 285 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var globalThis = __webpack_require__(4); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var call = __webpack_require__(8); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var isArray = __webpack_require__(88); +var hasOwn = __webpack_require__(38); +var toString = __webpack_require__(68); +var lengthOfArrayLike = __webpack_require__(63); +var createProperty = __webpack_require__(90); +var fails = __webpack_require__(7); +var parseJSONString = __webpack_require__(97); +var NATIVE_SYMBOL = __webpack_require__(26); + +var JSON = globalThis.JSON; +var Number = globalThis.Number; +var SyntaxError = globalThis.SyntaxError; +var nativeParse = JSON && JSON.parse; +var enumerableOwnProperties = getBuiltIn('Object', 'keys'); +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var at = uncurryThis(''.charAt); +var slice = uncurryThis(''.slice); +var exec = uncurryThis(/./.exec); +var push = uncurryThis([].push); + +var IS_DIGIT = /^\d$/; +var IS_NON_ZERO_DIGIT = /^[1-9]$/; +var IS_NUMBER_START = /^[\d-]$/; +var IS_WHITESPACE = /^[\t\n\r ]$/; + +var PRIMITIVE = 0; +var OBJECT = 1; + +var $parse = function (source, reviver) { + source = toString(source); + var context = new Context(source, 0, ''); + var root = context.parse(); + var value = root.value; + var endIndex = context.skip(IS_WHITESPACE, root.end); + if (endIndex < source.length) { + throw new SyntaxError('Unexpected extra character: "' + at(source, endIndex) + '" after the parsed data at: ' + endIndex); + } + return isCallable(reviver) ? internalize({ '': value }, '', reviver, root) : value; +}; + +var internalize = function (holder, name, reviver, node) { + var val = holder[name]; + var unmodified = node && val === node.value; + var context = unmodified && typeof node.source == 'string' ? { source: node.source } : {}; + var elementRecordsLen, keys, len, i, P; + if (isObject(val)) { + var nodeIsArray = isArray(val); + var nodes = unmodified ? node.nodes : nodeIsArray ? [] : {}; + if (nodeIsArray) { + elementRecordsLen = nodes.length; + len = lengthOfArrayLike(val); + for (i = 0; i < len; i++) { + internalizeProperty(val, i, internalize(val, '' + i, reviver, i < elementRecordsLen ? nodes[i] : undefined)); + } + } else { + keys = enumerableOwnProperties(val); + len = lengthOfArrayLike(keys); + for (i = 0; i < len; i++) { + P = keys[i]; + internalizeProperty(val, P, internalize(val, P, reviver, hasOwn(nodes, P) ? nodes[P] : undefined)); + } + } + } + return call(reviver, holder, name, val, context); +}; + +var internalizeProperty = function (object, key, value) { + if (DESCRIPTORS) { + var descriptor = getOwnPropertyDescriptor(object, key); + if (descriptor && !descriptor.configurable) return; + } + if (value === undefined) delete object[key]; + else createProperty(object, key, value); +}; + +var Node = function (value, end, source, nodes) { + this.value = value; + this.end = end; + this.source = source; + this.nodes = nodes; +}; + +var Context = function (source, index) { + this.source = source; + this.index = index; +}; + +// https://www.json.org/json-en.html +Context.prototype = { + fork: function (nextIndex) { + return new Context(this.source, nextIndex); + }, + parse: function () { + var source = this.source; + var i = this.skip(IS_WHITESPACE, this.index); + var fork = this.fork(i); + var chr = at(source, i); + if (exec(IS_NUMBER_START, chr)) return fork.number(); + switch (chr) { + case '{': + return fork.object(); + case '[': + return fork.array(); + case '"': + return fork.string(); + case 't': + return fork.keyword(true); + case 'f': + return fork.keyword(false); + case 'n': + return fork.keyword(null); + } throw new SyntaxError('Unexpected character: "' + chr + '" at: ' + i); + }, + node: function (type, value, start, end, nodes) { + return new Node(value, end, type ? null : slice(this.source, start, end), nodes); + }, + object: function () { + var source = this.source; + var i = this.index + 1; + var expectKeypair = false; + var object = {}; + var nodes = {}; + var closed = false; + while (i < source.length) { + i = this.until(['"', '}'], i); + if (at(source, i) === '}' && !expectKeypair) { + i++; + closed = true; + break; + } + // Parsing the key + var result = this.fork(i).string(); + var key = result.value; + i = result.end; + i = this.until([':'], i) + 1; + // Parsing value + i = this.skip(IS_WHITESPACE, i); + result = this.fork(i).parse(); + createProperty(nodes, key, result); + createProperty(object, key, result.value); + i = this.until([',', '}'], result.end); + var chr = at(source, i); + if (chr === ',') { + expectKeypair = true; + i++; + } else if (chr === '}') { + i++; + closed = true; + break; + } + } + if (!closed) throw new SyntaxError('Unterminated object at: ' + i); + return this.node(OBJECT, object, this.index, i, nodes); + }, + array: function () { + var source = this.source; + var i = this.index + 1; + var expectElement = false; + var array = []; + var nodes = []; + var closed = false; + while (i < source.length) { + i = this.skip(IS_WHITESPACE, i); + if (at(source, i) === ']' && !expectElement) { + i++; + closed = true; + break; + } + var result = this.fork(i).parse(); + push(nodes, result); + push(array, result.value); + i = this.until([',', ']'], result.end); + if (at(source, i) === ',') { + expectElement = true; + i++; + } else if (at(source, i) === ']') { + i++; + closed = true; + break; + } + } + if (!closed) throw new SyntaxError('Unterminated array at: ' + i); + return this.node(OBJECT, array, this.index, i, nodes); + }, + string: function () { + var index = this.index; + var parsed = parseJSONString(this.source, this.index + 1); + return this.node(PRIMITIVE, parsed.value, index, parsed.end); + }, + number: function () { + var source = this.source; + var startIndex = this.index; + var i = startIndex; + if (at(source, i) === '-') i++; + if (at(source, i) === '0') i++; + else if (exec(IS_NON_ZERO_DIGIT, at(source, i))) i = this.skip(IS_DIGIT, i + 1); + else throw new SyntaxError('Failed to parse number at: ' + i); + if (at(source, i) === '.') { + var fractionStartIndex = i + 1; + i = this.skip(IS_DIGIT, fractionStartIndex); + if (fractionStartIndex === i) throw new SyntaxError("Failed to parse number's fraction at: " + i); + } + if (at(source, i) === 'e' || at(source, i) === 'E') { + i++; + if (at(source, i) === '+' || at(source, i) === '-') i++; + var exponentStartIndex = i; + i = this.skip(IS_DIGIT, i); + if (exponentStartIndex === i) throw new SyntaxError("Failed to parse number's exponent value at: " + i); + } + return this.node(PRIMITIVE, Number(slice(source, startIndex, i)), startIndex, i); + }, + keyword: function (value) { + var keyword = '' + value; + var index = this.index; + var endIndex = index + keyword.length; + if (slice(this.source, index, endIndex) !== keyword) throw new SyntaxError('Failed to parse value at: ' + index); + return this.node(PRIMITIVE, value, index, endIndex); + }, + skip: function (regex, i) { + var source = this.source; + for (; i < source.length; i++) if (!exec(regex, at(source, i))) break; + return i; + }, + until: function (array, i) { + i = this.skip(IS_WHITESPACE, i); + var chr = at(this.source, i); + for (var j = 0; j < array.length; j++) if (array[j] === chr) return i; + throw new SyntaxError('Unexpected character: "' + chr + '" at: ' + i); + } +}; + +var NO_SOURCE_SUPPORT = fails(function () { + var unsafeInt = '9007199254740993'; + var source; + nativeParse(unsafeInt, function (key, value, context) { + source = context.source; + }); + return source !== unsafeInt; +}); + +var PROPER_BASE_PARSE = NATIVE_SYMBOL && !fails(function () { + // Safari 9 bug + return 1 / nativeParse('-0 \t') !== -Infinity; +}); + +// `JSON.parse` method +// https://tc39.es/ecma262/#sec-json.parse +// https://github.com/tc39/proposal-json-parse-with-source +$({ target: 'JSON', stat: true, forced: NO_SOURCE_SUPPORT }, { + parse: function parse(text, reviver) { + return PROPER_BASE_PARSE && !isCallable(reviver) ? nativeParse(text) : $parse(text, reviver); + } +}); + + +/***/ }), +/* 286 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var FREEZING = __webpack_require__(287); +var NATIVE_RAW_JSON = __webpack_require__(98); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); +var createProperty = __webpack_require__(90); +var setInternalState = __webpack_require__(51).set; + +var $SyntaxError = SyntaxError; +var parse = getBuiltIn('JSON', 'parse'); +var create = getBuiltIn('Object', 'create'); +var freeze = getBuiltIn('Object', 'freeze'); +var at = uncurryThis(''.charAt); + +var ERROR_MESSAGE = 'Unacceptable as raw JSON'; + +var isWhitespace = function (it) { + return it === ' ' || it === '\t' || it === '\n' || it === '\r'; +}; + +// `JSON.rawJSON` method +// https://tc39.es/proposal-json-parse-with-source/#sec-json.rawjson +// https://github.com/tc39/proposal-json-parse-with-source +$({ target: 'JSON', stat: true, forced: !NATIVE_RAW_JSON }, { + rawJSON: function rawJSON(text) { + var jsonString = toString(text); + if (jsonString === '' || isWhitespace(at(jsonString, 0)) || isWhitespace(at(jsonString, jsonString.length - 1))) { + throw new $SyntaxError(ERROR_MESSAGE); + } + var parsed = parse(jsonString); + if (typeof parsed == 'object' && parsed !== null) throw new $SyntaxError(ERROR_MESSAGE); + var obj = create(null); + setInternalState(obj, { type: 'RawJSON' }); + createProperty(obj, 'rawJSON', jsonString); + return FREEZING ? freeze(obj) : obj; + } +}); + + +/***/ }), +/* 287 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +module.exports = !fails(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); +}); + + +/***/ }), +/* 288 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var setToStringTag = __webpack_require__(82); + +// JSON[@@toStringTag] property +// https://tc39.es/ecma262/#sec-json-@@tostringtag +setToStringTag(globalThis.JSON, 'JSON', true); + + +/***/ }), +/* 289 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(290); + + +/***/ }), +/* 290 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var collection = __webpack_require__(291); +var collectionStrong = __webpack_require__(295); + +// `Map` constructor +// https://tc39.es/ecma262/#sec-map-objects +collection('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + + +/***/ }), +/* 291 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var isForced = __webpack_require__(67); +var defineBuiltIn = __webpack_require__(47); +var InternalMetadataModule = __webpack_require__(292); +var iterate = __webpack_require__(136); +var anInstance = __webpack_require__(215); +var isCallable = __webpack_require__(21); +var isNullOrUndefined = __webpack_require__(17); +var isObject = __webpack_require__(20); +var fails = __webpack_require__(7); +var checkCorrectnessOfIteration = __webpack_require__(171); +var setToStringTag = __webpack_require__(82); +var inheritIfRequired = __webpack_require__(123); + +module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = globalThis[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]); + defineBuiltIn(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + + +/***/ }), +/* 292 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var hiddenKeys = __webpack_require__(54); +var isObject = __webpack_require__(20); +var hasOwn = __webpack_require__(38); +var defineProperty = __webpack_require__(44).f; +var getOwnPropertyNamesModule = __webpack_require__(57); +var getOwnPropertyNamesExternalModule = __webpack_require__(75); +var isExtensible = __webpack_require__(293); +var uid = __webpack_require__(40); +var FREEZING = __webpack_require__(287); + +var REQUIRED = false; +var METADATA = uid('meta'); +var id = 0; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!hasOwn(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis([].splice); + var test = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = module.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + + +/***/ }), +/* 293 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var isObject = __webpack_require__(20); +var classof = __webpack_require__(15); +var ARRAY_BUFFER_NON_EXTENSIBLE = __webpack_require__(294); + +// eslint-disable-next-line es/no-object-isextensible -- safe +var $isExtensible = Object.isExtensible; +var FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); }); + +// `Object.isExtensible` method +// https://tc39.es/ecma262/#sec-object.isextensible +module.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; +} : $isExtensible; + + +/***/ }), +/* 294 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it +var fails = __webpack_require__(7); + +module.exports = fails(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } +}); + + +/***/ }), +/* 295 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var create = __webpack_require__(71); +var defineBuiltInAccessor = __webpack_require__(77); +var defineBuiltIns = __webpack_require__(214); +var bind = __webpack_require__(84); +var anInstance = __webpack_require__(215); +var isNullOrUndefined = __webpack_require__(17); +var iterate = __webpack_require__(136); +var defineIterator = __webpack_require__(176); +var createIterResultObject = __webpack_require__(179); +var setSpecies = __webpack_require__(200); +var DESCRIPTORS = __webpack_require__(6); +var fastKey = __webpack_require__(292).fastKey; +var InternalStateModule = __webpack_require__(51); + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; + +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: null, + last: null, + size: 0 + }); + if (!DESCRIPTORS) that.size = 0; + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: null, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key === key) return entry; + } + }; + + defineBuiltIns(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = null; + entry = entry.next; + } + state.first = state.last = null; + state.index = create(null); + if (DESCRIPTORS) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first === entry) state.first = next; + if (state.last === entry) state.last = prev; + if (DESCRIPTORS) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', { + configurable: true, + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: null + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = null; + return createIterResultObject(undefined, true); + } + // return step by kind + if (kind === 'keys') return createIterResultObject(entry.key, false); + if (kind === 'values') return createIterResultObject(entry.value, false); + return createIterResultObject([entry.key, entry.value], false); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } +}; + + +/***/ }), +/* 296 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); +var requireObjectCoercible = __webpack_require__(16); +var iterate = __webpack_require__(136); +var MapHelpers = __webpack_require__(297); +var IS_PURE = __webpack_require__(36); +var fails = __webpack_require__(7); + +var Map = MapHelpers.Map; +var has = MapHelpers.has; +var get = MapHelpers.get; +var set = MapHelpers.set; +var push = uncurryThis([].push); + +// https://bugs.webkit.org/show_bug.cgi?id=271524 +var DOES_NOT_WORK_WITH_PRIMITIVES = IS_PURE || fails(function () { + return Map.groupBy('ab', function (it) { + return it; + }).get('a').length !== 1; +}); + +// `Map.groupBy` method +// https://tc39.es/ecma262/#sec-map.groupby +$({ target: 'Map', stat: true, forced: IS_PURE || DOES_NOT_WORK_WITH_PRIMITIVES }, { + groupBy: function groupBy(items, callbackfn) { + requireObjectCoercible(items); + aCallable(callbackfn); + var map = new Map(); + var k = 0; + iterate(items, function (value) { + var key = callbackfn(value, k++); + if (!has(map, key)) set(map, key, [value]); + else push(get(map, key), value); + }); + return map; + } +}); + + +/***/ }), +/* 297 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +// eslint-disable-next-line es/no-map -- safe +var MapPrototype = Map.prototype; + +module.exports = { + // eslint-disable-next-line es/no-map -- safe + Map: Map, + set: uncurryThis(MapPrototype.set), + get: uncurryThis(MapPrototype.get), + has: uncurryThis(MapPrototype.has), + remove: uncurryThis(MapPrototype['delete']), + proto: MapPrototype +}; + + +/***/ }), +/* 298 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var MapHelpers = __webpack_require__(297); +var IS_PURE = __webpack_require__(36); + +var get = MapHelpers.get; +var has = MapHelpers.has; +var set = MapHelpers.set; + +// `Map.prototype.getOrInsert` method +// https://tc39.es/ecma262/#sec-map.prototype.getorinsert +$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, { + getOrInsert: function getOrInsert(key, value) { + if (has(this, key)) return get(this, key); + set(this, key, value); + return value; + } +}); + + +/***/ }), +/* 299 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aCallable = __webpack_require__(30); +var MapHelpers = __webpack_require__(297); +var IS_PURE = __webpack_require__(36); + +var get = MapHelpers.get; +var has = MapHelpers.has; +var set = MapHelpers.set; + +// `Map.prototype.getOrInsertComputed` method +// https://tc39.es/ecma262/#sec-map.prototype.getorinsertcomputed +$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, { + getOrInsertComputed: function getOrInsertComputed(key, callbackfn) { + var hasKey = has(this, key); + aCallable(callbackfn); + if (hasKey) return get(this, key); + // CanonicalizeKeyedCollectionKey + if (key === 0 && 1 / key === -Infinity) key = 0; + var value = callbackfn(key); + set(this, key, value); + return value; + } +}); + + +/***/ }), +/* 300 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var log1p = __webpack_require__(301); + +// eslint-disable-next-line es/no-math-acosh -- required for testing +var $acosh = Math.acosh; +var log = Math.log; +var sqrt = Math.sqrt; +var LN2 = Math.LN2; + +var FORCED = !$acosh + // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509 + || Math.floor($acosh(Number.MAX_VALUE)) !== 710 + // Tor Browser bug: Math.acosh(Infinity) -> NaN + || $acosh(Infinity) !== Infinity; + +// `Math.acosh` method +// https://tc39.es/ecma262/#sec-math.acosh +$({ target: 'Math', stat: true, forced: FORCED }, { + acosh: function acosh(x) { + var n = +x; + return n < 1 ? NaN : n > 94906265.62425156 + ? log(n) + LN2 + : log1p(n - 1 + sqrt(n - 1) * sqrt(n + 1)); + } +}); + + +/***/ }), +/* 301 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var log = Math.log; + +// `Math.log1p` method implementation +// https://tc39.es/ecma262/#sec-math.log1p +// eslint-disable-next-line es/no-math-log1p -- safe +module.exports = Math.log1p || function log1p(x) { + var n = +x; + return n > -1e-8 && n < 1e-8 ? n - n * n / 2 : log(1 + n); +}; + + +/***/ }), +/* 302 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// eslint-disable-next-line es/no-math-asinh -- required for testing +var $asinh = Math.asinh; +var log = Math.log; +var sqrt = Math.sqrt; +var LN2 = Math.LN2; +// sqrt(2 ** 53) - prevent n * n overflow +var SQRT_2_POW_53 = 94906265.62425156; + +function asinh(x) { + var n = +x; + return !isFinite(n) || n === 0 ? n : n < 0 ? -asinh(-n) : n > SQRT_2_POW_53 ? log(n) + LN2 : log(n + sqrt(n * n + 1)); +} + +var FORCED = !($asinh && 1 / $asinh(0) > 0); + +// `Math.asinh` method +// https://tc39.es/ecma262/#sec-math.asinh +// Tor Browser bug: Math.asinh(0) -> -0 +$({ target: 'Math', stat: true, forced: FORCED }, { + asinh: asinh +}); + + +/***/ }), +/* 303 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var log1p = __webpack_require__(301); + +// eslint-disable-next-line es/no-math-atanh -- required for testing +var $atanh = Math.atanh; + +var FORCED = !($atanh && 1 / $atanh(-0) < 0); + +// `Math.atanh` method +// https://tc39.es/ecma262/#sec-math.atanh +// Tor Browser bug: Math.atanh(-0) -> 0 +$({ target: 'Math', stat: true, forced: FORCED }, { + atanh: function atanh(x) { + var n = +x; + return n === 0 ? n : log1p(2 * n / (1 - n)) / 2; + } +}); + + +/***/ }), +/* 304 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var sign = __webpack_require__(219); + +var abs = Math.abs; +var pow = Math.pow; + +// `Math.cbrt` method +// https://tc39.es/ecma262/#sec-math.cbrt +$({ target: 'Math', stat: true }, { + cbrt: function cbrt(x) { + var n = +x; + return sign(n) * pow(abs(n), 1 / 3); + } +}); + + +/***/ }), +/* 305 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +var floor = Math.floor; +var log = Math.log; +var LOG2E = Math.LOG2E; + +// `Math.clz32` method +// https://tc39.es/ecma262/#sec-math.clz32 +$({ target: 'Math', stat: true }, { + clz32: function clz32(x) { + var n = x >>> 0; + return n ? 31 - floor(log(n + 0.5) * LOG2E) : 32; + } +}); + + +/***/ }), +/* 306 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var expm1 = __webpack_require__(307); + +// eslint-disable-next-line es/no-math-cosh -- required for testing +var $cosh = Math.cosh; +var abs = Math.abs; +var E = Math.E; + +var FORCED = !$cosh || $cosh(710) === Infinity; + +// `Math.cosh` method +// https://tc39.es/ecma262/#sec-math.cosh +$({ target: 'Math', stat: true, forced: FORCED }, { + cosh: function cosh(x) { + var t = expm1(abs(x) - 1) + 1; + return (t + 1 / (t * E * E)) * (E / 2); + } +}); + + +/***/ }), +/* 307 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// eslint-disable-next-line es/no-math-expm1 -- safe +var $expm1 = Math.expm1; +var exp = Math.exp; + +// `Math.expm1` method implementation +// https://tc39.es/ecma262/#sec-math.expm1 +module.exports = (!$expm1 + // Old FF bug + // eslint-disable-next-line no-loss-of-precision -- required for old engines + || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168 + // Tor Browser bug + || $expm1(-2e-17) !== -2e-17 +) ? function expm1(x) { + var n = +x; + return n === 0 ? n : n > -1e-6 && n < 1e-6 ? n + n * n / 2 : exp(n) - 1; +} : $expm1; + + +/***/ }), +/* 308 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var expm1 = __webpack_require__(307); + +// `Math.expm1` method +// https://tc39.es/ecma262/#sec-math.expm1 +// eslint-disable-next-line es/no-math-expm1 -- required for testing +$({ target: 'Math', stat: true, forced: expm1 !== Math.expm1 }, { expm1: expm1 }); + + +/***/ }), +/* 309 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fround = __webpack_require__(217); + +// `Math.fround` method +// https://tc39.es/ecma262/#sec-math.fround +$({ target: 'Math', stat: true }, { fround: fround }); + + +/***/ }), +/* 310 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var floatRound = __webpack_require__(218); + +var FLOAT16_EPSILON = 0.0009765625; +var FLOAT16_MAX_VALUE = 65504; +var FLOAT16_MIN_VALUE = 6.103515625e-05; + +// `Math.f16round` method +// https://tc39.es/ecma262/#sec-math.f16round +$({ target: 'Math', stat: true }, { + f16round: function f16round(x) { + return floatRound(x, FLOAT16_EPSILON, FLOAT16_MAX_VALUE, FLOAT16_MIN_VALUE); + } +}); + + +/***/ }), +/* 311 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// eslint-disable-next-line es/no-math-hypot -- required for testing +var $hypot = Math.hypot; +var abs = Math.abs; +var sqrt = Math.sqrt; + +// Chrome 77 bug +// https://bugs.chromium.org/p/v8/issues/detail?id=9546 +var FORCED = !!$hypot && $hypot(Infinity, NaN) !== Infinity; + +// `Math.hypot` method +// https://tc39.es/ecma262/#sec-math.hypot +$({ target: 'Math', stat: true, arity: 2, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + hypot: function hypot(value1, value2) { + var sum = 0; + var i = 0; + var aLen = arguments.length; + var larg = 0; + var arg, div; + while (i < aLen) { + arg = abs(arguments[i++]); + if (larg < arg) { + div = larg / arg; + sum = sum * div * div + 1; + larg = arg; + } else if (arg > 0) { + div = arg / larg; + sum += div * div; + } else sum += arg; + } + return larg === Infinity ? Infinity : larg * sqrt(sum); + } +}); + + +/***/ }), +/* 312 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); + +// eslint-disable-next-line es/no-math-imul -- required for testing +var $imul = Math.imul; + +var FORCED = fails(function () { + return $imul(0xFFFFFFFF, 5) !== -5 || $imul.length !== 2; +}); + +// `Math.imul` method +// https://tc39.es/ecma262/#sec-math.imul +// some WebKit versions fails with big numbers, some has wrong arity +$({ target: 'Math', stat: true, forced: FORCED }, { + imul: function imul(x, y) { + var UINT16 = 0xFFFF; + var xn = +x; + var yn = +y; + var xl = UINT16 & xn; + var yl = UINT16 & yn; + return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0); + } +}); + + +/***/ }), +/* 313 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var log10 = __webpack_require__(314); + +// `Math.log10` method +// https://tc39.es/ecma262/#sec-math.log10 +$({ target: 'Math', stat: true }, { + log10: log10 +}); + + +/***/ }), +/* 314 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var log = Math.log; +var LOG10E = Math.LOG10E; + +// eslint-disable-next-line es/no-math-log10 -- safe +module.exports = Math.log10 || function log10(x) { + return log(x) * LOG10E; +}; + + +/***/ }), +/* 315 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var log1p = __webpack_require__(301); + +// `Math.log1p` method +// https://tc39.es/ecma262/#sec-math.log1p +$({ target: 'Math', stat: true }, { log1p: log1p }); + + +/***/ }), +/* 316 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var log2 = __webpack_require__(230); + +// `Math.log2` method +// https://tc39.es/ecma262/#sec-math.log2 +$({ target: 'Math', stat: true }, { + log2: log2 +}); + + +/***/ }), +/* 317 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var sign = __webpack_require__(219); + +// `Math.sign` method +// https://tc39.es/ecma262/#sec-math.sign +$({ target: 'Math', stat: true }, { + sign: sign +}); + + +/***/ }), +/* 318 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var expm1 = __webpack_require__(307); + +var abs = Math.abs; +var exp = Math.exp; +var E = Math.E; + +var FORCED = fails(function () { + // eslint-disable-next-line es/no-math-sinh -- required for testing + return Math.sinh(-2e-17) !== -2e-17; +}); + +// `Math.sinh` method +// https://tc39.es/ecma262/#sec-math.sinh +// V8 near Chromium 38 has a problem with very small numbers +$({ target: 'Math', stat: true, forced: FORCED }, { + sinh: function sinh(x) { + var n = +x; + return abs(n) < 1 ? (expm1(n) - expm1(-n)) / 2 : (exp(n - 1) - exp(-n - 1)) * (E / 2); + } +}); + + +/***/ }), +/* 319 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// based on Shewchuk's algorithm for exactly floating point addition +// adapted from https://github.com/tc39/proposal-math-sum/blob/3513d58323a1ae25560e8700aa5294500c6c9287/polyfill/polyfill.mjs +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var iterate = __webpack_require__(136); + +var $RangeError = RangeError; +var $TypeError = TypeError; +var $Infinity = Infinity; +var $NaN = NaN; +var abs = Math.abs; +var pow = Math.pow; +var push = uncurryThis([].push); + +var POW_2_1023 = pow(2, 1023); +var MAX_SAFE_INTEGER = pow(2, 53) - 1; // 2 ** 53 - 1 === 9007199254740991 +var MAX_DOUBLE = Number.MAX_VALUE; // 2 ** 1024 - 2 ** (1023 - 52) === 1.79769313486231570815e+308 +var MAX_ULP = pow(2, 971); // 2 ** (1023 - 52) === 1.99584030953471981166e+292 + +var NOT_A_NUMBER = {}; +var MINUS_INFINITY = {}; +var PLUS_INFINITY = {}; +var MINUS_ZERO = {}; +var FINITE = {}; + +// prerequisite: abs(x) >= abs(y) +var twosum = function (x, y) { + var hi = x + y; + var lo = y - (hi - x); + return { hi: hi, lo: lo }; +}; + +// `Math.sumPrecise` method +// https://tc39.es/ecma262/#sec-math.sumprecise +$({ target: 'Math', stat: true }, { + // eslint-disable-next-line max-statements -- ok + sumPrecise: function sumPrecise(items) { + var numbers = []; + var count = 0; + var state = MINUS_ZERO; + + iterate(items, function (n) { + if (++count > MAX_SAFE_INTEGER) throw new $RangeError('Maximum allowed index exceeded'); + if (typeof n != 'number') throw new $TypeError('Value is not a number'); + if (state !== NOT_A_NUMBER) { + // eslint-disable-next-line no-self-compare -- NaN check + if (n !== n) state = NOT_A_NUMBER; + else if (n === $Infinity) state = state === MINUS_INFINITY ? NOT_A_NUMBER : PLUS_INFINITY; + else if (n === -$Infinity) state = state === PLUS_INFINITY ? NOT_A_NUMBER : MINUS_INFINITY; + else if ((n !== 0 || (1 / n) === $Infinity) && (state === MINUS_ZERO || state === FINITE)) { + state = FINITE; + push(numbers, n); + } + } + }); + + switch (state) { + case NOT_A_NUMBER: return $NaN; + case MINUS_INFINITY: return -$Infinity; + case PLUS_INFINITY: return $Infinity; + case MINUS_ZERO: return -0; + } + + var partials = []; + var overflow = 0; // conceptually 2 ** 1024 times this value; the final partial is biased by this amount + var x, y, sum, hi, lo, tmp; + + for (var i = 0; i < numbers.length; i++) { + x = numbers[i]; + var actuallyUsedPartials = 0; + for (var j = 0; j < partials.length; j++) { + y = partials[j]; + if (abs(x) < abs(y)) { + tmp = x; + x = y; + y = tmp; + } + sum = twosum(x, y); + hi = sum.hi; + lo = sum.lo; + if (abs(hi) === $Infinity) { + var sign = hi === $Infinity ? 1 : -1; + overflow += sign; + + x = (x - (sign * POW_2_1023)) - (sign * POW_2_1023); + if (abs(x) < abs(y)) { + tmp = x; + x = y; + y = tmp; + } + sum = twosum(x, y); + hi = sum.hi; + lo = sum.lo; + } + if (lo !== 0) partials[actuallyUsedPartials++] = lo; + x = hi; + } + partials.length = actuallyUsedPartials; + if (x !== 0) push(partials, x); + } + + // compute the exact sum of partials, stopping once we lose precision + var n = partials.length - 1; + hi = 0; + lo = 0; + + if (overflow !== 0) { + var next = n >= 0 ? partials[n] : 0; + n--; + if (abs(overflow) > 1 || (overflow > 0 && next > 0) || (overflow < 0 && next < 0)) { + return overflow > 0 ? $Infinity : -$Infinity; + } + // here we actually have to do the arithmetic + // drop a factor of 2 so we can do it without overflow + // assert(abs(overflow) === 1) + sum = twosum(overflow * POW_2_1023, next / 2); + hi = sum.hi; + lo = sum.lo; + lo *= 2; + if (abs(2 * hi) === $Infinity) { + // rounding to the maximum value + if (hi > 0) { + return (hi === POW_2_1023 && lo === -(MAX_ULP / 2) && n >= 0 && partials[n] < 0) ? MAX_DOUBLE : $Infinity; + } return (hi === -POW_2_1023 && lo === (MAX_ULP / 2) && n >= 0 && partials[n] > 0) ? -MAX_DOUBLE : -$Infinity; + } + + if (lo !== 0) { + partials[++n] = lo; + lo = 0; + } + + hi *= 2; + } + + while (n >= 0) { + sum = twosum(hi, partials[n--]); + hi = sum.hi; + lo = sum.lo; + if (lo !== 0) break; + } + + if (n >= 0 && ((lo < 0 && partials[n] < 0) || (lo > 0 && partials[n] > 0))) { + y = lo * 2; + x = hi + y; + if (y === x - hi) hi = x; + } + + return hi; + } +}); + + +/***/ }), +/* 320 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var expm1 = __webpack_require__(307); + +var exp = Math.exp; + +// `Math.tanh` method +// https://tc39.es/ecma262/#sec-math.tanh +$({ target: 'Math', stat: true }, { + tanh: function tanh(x) { + var n = +x; + var a = expm1(n); + var b = expm1(-n); + return a === Infinity ? 1 : b === Infinity ? -1 : (a - b) / (exp(n) + exp(-n)); + } +}); + + +/***/ }), +/* 321 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var setToStringTag = __webpack_require__(82); + +// Math[@@toStringTag] property +// https://tc39.es/ecma262/#sec-math-@@tostringtag +setToStringTag(Math, 'Math', true); + + +/***/ }), +/* 322 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var trunc = __webpack_require__(62); + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +$({ target: 'Math', stat: true }, { + trunc: trunc +}); + + +/***/ }), +/* 323 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var IS_PURE = __webpack_require__(36); +var DESCRIPTORS = __webpack_require__(6); +var globalThis = __webpack_require__(4); +var path = __webpack_require__(80); +var uncurryThis = __webpack_require__(14); +var isForced = __webpack_require__(67); +var hasOwn = __webpack_require__(38); +var inheritIfRequired = __webpack_require__(123); +var isPrototypeOf = __webpack_require__(24); +var isSymbol = __webpack_require__(22); +var toPrimitive = __webpack_require__(19); +var fails = __webpack_require__(7); +var getOwnPropertyNames = __webpack_require__(57).f; +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var defineProperty = __webpack_require__(44).f; +var thisNumberValue = __webpack_require__(324); +var trim = __webpack_require__(325).trim; + +var NUMBER = 'Number'; +var NativeNumber = globalThis[NUMBER]; +var PureNumberNamespace = path[NUMBER]; +var NumberPrototype = NativeNumber.prototype; +var TypeError = globalThis.TypeError; +var stringSlice = uncurryThis(''.slice); +var charCodeAt = uncurryThis(''.charCodeAt); + +// `ToNumeric` abstract operation +// https://tc39.es/ecma262/#sec-tonumeric +var toNumeric = function (value) { + var primValue = toPrimitive(value, 'number'); + return typeof primValue == 'bigint' ? primValue : toNumber(primValue); +}; + +// `ToNumber` abstract operation +// https://tc39.es/ecma262/#sec-tonumber +var toNumber = function (argument) { + var it = toPrimitive(argument, 'number'); + var first, third, radix, maxCode, digits, length, index, code; + if (isSymbol(it)) throw new TypeError('Cannot convert a Symbol value to a number'); + if (typeof it == 'string' && it.length > 2) { + it = trim(it); + first = charCodeAt(it, 0); + if (first === 43 || first === 45) { + third = charCodeAt(it, 2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (charCodeAt(it, 1)) { + // fast equal of /^0b[01]+$/i + case 66: + case 98: + radix = 2; + maxCode = 49; + break; + // fast equal of /^0o[0-7]+$/i + case 79: + case 111: + radix = 8; + maxCode = 55; + break; + default: + return +it; + } + digits = stringSlice(it, 2); + length = digits.length; + for (index = 0; index < length; index++) { + code = charCodeAt(digits, index); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); + } + } return +it; +}; + +var FORCED = isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1')); + +var calledWithNew = function (dummy) { + // includes check on 1..constructor(foo) case + return isPrototypeOf(NumberPrototype, dummy) && fails(function () { thisNumberValue(dummy); }); +}; + +// `Number` constructor +// https://tc39.es/ecma262/#sec-number-constructor +var NumberWrapper = function Number(value) { + var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value)); + return calledWithNew(this) ? inheritIfRequired(Object(n), this, NumberWrapper) : n; +}; + +NumberWrapper.prototype = NumberPrototype; +if (FORCED && !IS_PURE) NumberPrototype.constructor = NumberWrapper; + +$({ global: true, constructor: true, wrap: true, forced: FORCED }, { + Number: NumberWrapper +}); + +// Use `internal/copy-constructor-properties` helper in `core-js@4` +var copyConstructorProperties = function (target, source) { + for (var keys = DESCRIPTORS ? getOwnPropertyNames(source) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES2015 (in case, if modules with ES2015 Number statics required before): + 'EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,' + + // ESNext + 'fromString,range' + ).split(','), j = 0, key; keys.length > j; j++) { + if (hasOwn(source, key = keys[j]) && !hasOwn(target, key)) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + +if (IS_PURE && PureNumberNamespace) copyConstructorProperties(path[NUMBER], PureNumberNamespace); +if (FORCED || IS_PURE) copyConstructorProperties(path[NUMBER], NativeNumber); + + +/***/ }), +/* 324 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +// `thisNumberValue` abstract operation +// https://tc39.es/ecma262/#sec-thisnumbervalue +module.exports = uncurryThis(1.1.valueOf); + + +/***/ }), +/* 325 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var toString = __webpack_require__(68); +var whitespaces = __webpack_require__(326); + +var replace = uncurryThis(''.replace); +var ltrim = RegExp('^[' + whitespaces + ']+'); +var rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod = function (TYPE) { + return function ($this) { + var string = toString(requireObjectCoercible($this)); + if (TYPE & 1) string = replace(string, ltrim, ''); + if (TYPE & 2) string = replace(string, rtrim, '$1'); + return string; + }; +}; + +module.exports = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod(3) +}; + + +/***/ }), +/* 326 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// a string of all valid unicode whitespaces +module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + +/***/ }), +/* 327 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Number.EPSILON` constant +// https://tc39.es/ecma262/#sec-number.epsilon +$({ target: 'Number', stat: true, nonConfigurable: true, nonWritable: true }, { + EPSILON: Math.pow(2, -52) +}); + + +/***/ }), +/* 328 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var numberIsFinite = __webpack_require__(329); + +// `Number.isFinite` method +// https://tc39.es/ecma262/#sec-number.isfinite +$({ target: 'Number', stat: true }, { isFinite: numberIsFinite }); + + +/***/ }), +/* 329 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +var globalIsFinite = globalThis.isFinite; + +// `Number.isFinite` method +// https://tc39.es/ecma262/#sec-number.isfinite +// eslint-disable-next-line es/no-number-isfinite -- safe +module.exports = Number.isFinite || function isFinite(it) { + return typeof it == 'number' && globalIsFinite(it); +}; + + +/***/ }), +/* 330 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isIntegralNumber = __webpack_require__(331); + +// `Number.isInteger` method +// https://tc39.es/ecma262/#sec-number.isinteger +$({ target: 'Number', stat: true }, { + isInteger: isIntegralNumber +}); + + +/***/ }), +/* 331 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); + +var floor = Math.floor; + +// `IsIntegralNumber` abstract operation +// https://tc39.es/ecma262/#sec-isintegralnumber +// eslint-disable-next-line es/no-number-isinteger -- safe +module.exports = Number.isInteger || function isInteger(it) { + return !isObject(it) && isFinite(it) && floor(it) === it; +}; + + +/***/ }), +/* 332 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Number.isNaN` method +// https://tc39.es/ecma262/#sec-number.isnan +$({ target: 'Number', stat: true }, { + isNaN: function isNaN(number) { + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number; + } +}); + + +/***/ }), +/* 333 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isIntegralNumber = __webpack_require__(331); + +var abs = Math.abs; + +// `Number.isSafeInteger` method +// https://tc39.es/ecma262/#sec-number.issafeinteger +$({ target: 'Number', stat: true }, { + isSafeInteger: function isSafeInteger(number) { + return isIntegralNumber(number) && abs(number) <= 0x1FFFFFFFFFFFFF; + } +}); + + +/***/ }), +/* 334 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Number.MAX_SAFE_INTEGER` constant +// https://tc39.es/ecma262/#sec-number.max_safe_integer +$({ target: 'Number', stat: true, nonConfigurable: true, nonWritable: true }, { + MAX_SAFE_INTEGER: 0x1FFFFFFFFFFFFF +}); + + +/***/ }), +/* 335 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Number.MIN_SAFE_INTEGER` constant +// https://tc39.es/ecma262/#sec-number.min_safe_integer +$({ target: 'Number', stat: true, nonConfigurable: true, nonWritable: true }, { + MIN_SAFE_INTEGER: -0x1FFFFFFFFFFFFF +}); + + +/***/ }), +/* 336 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var parseFloat = __webpack_require__(337); + +// `Number.parseFloat` method +// https://tc39.es/ecma262/#sec-number.parseFloat +// eslint-disable-next-line es/no-number-parsefloat -- required for testing +$({ target: 'Number', stat: true, forced: Number.parseFloat !== parseFloat }, { + parseFloat: parseFloat +}); + + +/***/ }), +/* 337 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); +var trim = __webpack_require__(325).trim; +var whitespaces = __webpack_require__(326); + +var charAt = uncurryThis(''.charAt); +var $parseFloat = globalThis.parseFloat; +var Symbol = globalThis.Symbol; +var ITERATOR = Symbol && Symbol.iterator; +var FORCED = 1 / $parseFloat(whitespaces + '-0') !== -Infinity + // MS Edge 18- broken with boxed symbols + || (ITERATOR && !fails(function () { $parseFloat(Object(ITERATOR)); })); + +// `parseFloat` method +// https://tc39.es/ecma262/#sec-parsefloat-string +module.exports = FORCED ? function parseFloat(string) { + var trimmedString = trim(toString(string)); + var result = $parseFloat(trimmedString); + return result === 0 && charAt(trimmedString, 0) === '-' ? -0 : result; +} : $parseFloat; + + +/***/ }), +/* 338 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var parseInt = __webpack_require__(339); + +// `Number.parseInt` method +// https://tc39.es/ecma262/#sec-number.parseint +// eslint-disable-next-line es/no-number-parseint -- required for testing +$({ target: 'Number', stat: true, forced: Number.parseInt !== parseInt }, { + parseInt: parseInt +}); + + +/***/ }), +/* 339 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); +var trim = __webpack_require__(325).trim; +var whitespaces = __webpack_require__(326); + +var $parseInt = globalThis.parseInt; +var Symbol = globalThis.Symbol; +var ITERATOR = Symbol && Symbol.iterator; +var hex = /^[+-]?0x/i; +var exec = uncurryThis(hex.exec); +var FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22 + // MS Edge 18- broken with boxed symbols + || (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); })); + +// `parseInt` method +// https://tc39.es/ecma262/#sec-parseint-string-radix +module.exports = FORCED ? function parseInt(string, radix) { + var S = trim(toString(string)); + return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10)); +} : $parseInt; + + +/***/ }), +/* 340 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toIntegerOrInfinity = __webpack_require__(61); +var thisNumberValue = __webpack_require__(324); +var $repeat = __webpack_require__(248); +var log10 = __webpack_require__(314); +var fails = __webpack_require__(7); + +var $RangeError = RangeError; +var $String = String; +var $isFinite = isFinite; +var abs = Math.abs; +var floor = Math.floor; +var pow = Math.pow; +var round = Math.round; +var nativeToExponential = uncurryThis(1.1.toExponential); +var repeat = uncurryThis($repeat); +var stringSlice = uncurryThis(''.slice); + +var POW_10_308 = pow(10, 308); + +// Edge 17- +var ROUNDS_PROPERLY = nativeToExponential(-6.9e-11, 4) === '-6.9000e-11' + // IE11- && Edge 14- + && nativeToExponential(1.255, 2) === '1.25e+0' + // FF86-, V8 ~ Chrome 49-50 + && nativeToExponential(12345, 3) === '1.235e+4' + // FF86-, V8 ~ Chrome 49-50 + && nativeToExponential(25, 0) === '3e+1'; + +// IE8- +var throwsOnInfinityFraction = function () { + return fails(function () { + nativeToExponential(1, Infinity); + }) && fails(function () { + nativeToExponential(1, -Infinity); + }); +}; + +// Safari <11 && FF <50 +var properNonFiniteThisCheck = function () { + return !fails(function () { + nativeToExponential(Infinity, Infinity); + nativeToExponential(NaN, Infinity); + }); +}; + +var FORCED = !ROUNDS_PROPERLY || !throwsOnInfinityFraction() || !properNonFiniteThisCheck(); + +// `Number.prototype.toExponential` method +// https://tc39.es/ecma262/#sec-number.prototype.toexponential +$({ target: 'Number', proto: true, forced: FORCED }, { + toExponential: function toExponential(fractionDigits) { + var x = thisNumberValue(this); + if (fractionDigits === undefined) return nativeToExponential(x); + var f = toIntegerOrInfinity(fractionDigits); + if (!$isFinite(x)) return String(x); + // TODO: ES2018 increased the maximum number of fraction digits to 100, need to improve the implementation + if (f < 0 || f > 20) throw new $RangeError('Incorrect fraction digits'); + if (ROUNDS_PROPERLY) return nativeToExponential(x, f); + var s = ''; + var m, e, c, d, l, n, xScaled; + if (x < 0) { + s = '-'; + x = -x; + } + if (x === 0) { + e = 0; + m = repeat('0', f + 1); + } else { + // TODO: improve accuracy with big fraction digits + l = log10(x); + e = floor(l); + // compute x / pow(10, e - f) and round, avoiding underflow/overflow + if (f - e >= 308) { + // pow(10, e - f) would underflow to a subnormal or zero; split computation + xScaled = x * POW_10_308 * pow(10, f - e - 308); + } else { + xScaled = x / pow(10, e - f); + } + n = round(xScaled); + // correct tie-breaking: round half up + // avoids `2 * x` overflow for values near MAX_VALUE + if (xScaled - n >= 0.5) { + n += 1; + } + if (n >= pow(10, f + 1)) { + n /= 10; + e += 1; + } + m = $String(n); + } + if (f !== 0) { + m = stringSlice(m, 0, 1) + '.' + stringSlice(m, 1); + } + if (e === 0) { + c = '+'; + d = '0'; + } else { + c = e > 0 ? '+' : '-'; + d = $String(abs(e)); + } + m += 'e' + c + d; + return s + m; + } +}); + + +/***/ }), +/* 341 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toIntegerOrInfinity = __webpack_require__(61); +var thisNumberValue = __webpack_require__(324); +var $repeat = __webpack_require__(248); +var fails = __webpack_require__(7); + +var $RangeError = RangeError; +var $String = String; +var floor = Math.floor; +var repeat = uncurryThis($repeat); +var stringSlice = uncurryThis(''.slice); +var nativeToFixed = uncurryThis(1.1.toFixed); + +var pow = function (x, n, acc) { + return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); +}; + +var log = function (x) { + var n = 0; + var x2 = x; + while (x2 >= 4096) { + n += 12; + x2 /= 4096; + } + while (x2 >= 2) { + n += 1; + x2 /= 2; + } return n; +}; + +var multiply = function (data, n, c) { + var index = -1; + var c2 = c; + while (++index < 6) { + c2 += n * data[index]; + data[index] = c2 % 1e7; + c2 = floor(c2 / 1e7); + } +}; + +var divide = function (data, n) { + var index = 6; + var c = 0; + while (--index >= 0) { + c += data[index]; + data[index] = floor(c / n); + c = (c % n) * 1e7; + } +}; + +var dataToString = function (data) { + var index = 6; + var s = ''; + while (--index >= 0) { + if (s !== '' || index === 0 || data[index] !== 0) { + var t = $String(data[index]); + s = s === '' ? t : s + repeat('0', 7 - t.length) + t; + } + } return s; +}; + +var FORCED = fails(function () { + return nativeToFixed(0.00008, 3) !== '0.000' || + nativeToFixed(0.9, 0) !== '1' || + nativeToFixed(1.255, 2) !== '1.25' || + nativeToFixed(1000000000000000128.0, 0) !== '1000000000000000128'; +}) || !fails(function () { + // V8 ~ Android 4.3- + nativeToFixed({}); +}); + +// `Number.prototype.toFixed` method +// https://tc39.es/ecma262/#sec-number.prototype.tofixed +$({ target: 'Number', proto: true, forced: FORCED }, { + toFixed: function toFixed(fractionDigits) { + var number = thisNumberValue(this); + var fractDigits = toIntegerOrInfinity(fractionDigits); + var data = [0, 0, 0, 0, 0, 0]; + var sign = ''; + var result = '0'; + var e, z, j, k; + + // TODO: ES2018 increased the maximum number of fraction digits to 100, need to improve the implementation + if (fractDigits < 0 || fractDigits > 20) throw new $RangeError('Incorrect fraction digits'); + // eslint-disable-next-line no-self-compare -- NaN check + if (number !== number) return 'NaN'; + if (number <= -1e21 || number >= 1e21) return $String(number); + if (number < 0) { + sign = '-'; + number = -number; + } + if (number > 1e-21) { + e = log(number * pow(2, 69, 1)) - 69; + z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1); + z *= 0x10000000000000; + e = 52 - e; + if (e > 0) { + multiply(data, 0, z); + j = fractDigits; + while (j >= 7) { + multiply(data, 1e7, 0); + j -= 7; + } + multiply(data, pow(10, j, 1), 0); + j = e - 1; + while (j >= 23) { + divide(data, 1 << 23); + j -= 23; + } + divide(data, 1 << j); + multiply(data, 1, 1); + divide(data, 2); + result = dataToString(data); + } else { + multiply(data, 0, z); + multiply(data, 1 << -e, 0); + result = dataToString(data) + repeat('0', fractDigits); + } + } + if (fractDigits > 0) { + k = result.length; + result = sign + (k <= fractDigits + ? '0.' + repeat('0', fractDigits - k) + result + : stringSlice(result, 0, k - fractDigits) + '.' + stringSlice(result, k - fractDigits)); + } else { + result = sign + result; + } return result; + } +}); + + +/***/ }), +/* 342 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var thisNumberValue = __webpack_require__(324); + +var nativeToPrecision = uncurryThis(1.1.toPrecision); + +var FORCED = fails(function () { + // IE7- + return nativeToPrecision(1, undefined) !== '1'; +}) || !fails(function () { + // V8 ~ Android 4.3- + nativeToPrecision({}); +}); + +// `Number.prototype.toPrecision` method +// https://tc39.es/ecma262/#sec-number.prototype.toprecision +$({ target: 'Number', proto: true, forced: FORCED }, { + toPrecision: function toPrecision(precision) { + return precision === undefined + ? nativeToPrecision(thisNumberValue(this)) + : nativeToPrecision(thisNumberValue(this), precision); + } +}); + + +/***/ }), +/* 343 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var assign = __webpack_require__(344); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + + +/***/ }), +/* 344 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var uncurryThis = __webpack_require__(14); +var call = __webpack_require__(8); +var fails = __webpack_require__(7); +var objectKeys = __webpack_require__(73); +var getOwnPropertySymbolsModule = __webpack_require__(66); +var propertyIsEnumerableModule = __webpack_require__(10); +var toObject = __webpack_require__(39); +var IndexedObject = __webpack_require__(13); + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty = Object.defineProperty; +var concat = uncurryThis([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +module.exports = !$assign || fails(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', { + enumerable: true, + get: function () { + defineProperty(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + // eslint-disable-next-line es/no-array-prototype-foreach -- safe + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + + +/***/ }), +/* 345 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var create = __webpack_require__(71); + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { + create: create +}); + + +/***/ }), +/* 346 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var FORCED = __webpack_require__(347); +var aCallable = __webpack_require__(30); +var toObject = __webpack_require__(39); +var definePropertyModule = __webpack_require__(44); + +// `Object.prototype.__defineGetter__` method +// https://tc39.es/ecma262/#sec-object.prototype.__defineGetter__ +if (DESCRIPTORS) { + $({ target: 'Object', proto: true, forced: FORCED }, { + __defineGetter__: function __defineGetter__(P, getter) { + definePropertyModule.f(toObject(this), P, { get: aCallable(getter), enumerable: true, configurable: true }); + } + }); +} + + +/***/ }), +/* 347 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable no-undef, no-useless-call, sonarjs/no-reference-error -- required for testing */ +/* eslint-disable es/no-legacy-object-prototype-accessor-methods -- required for testing */ +var IS_PURE = __webpack_require__(36); +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); +var WEBKIT = __webpack_require__(198); + +// Forced replacement object prototype accessors methods +module.exports = IS_PURE || !fails(function () { + // This feature detection crashes old WebKit + // https://github.com/zloirock/core-js/issues/232 + if (WEBKIT && WEBKIT < 535) return; + var key = Math.random(); + // In FF throws only define methods + __defineSetter__.call(null, key, function () { /* empty */ }); + delete globalThis[key]; +}); + + +/***/ }), +/* 348 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var defineProperties = __webpack_require__(72).f; + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +$({ target: 'Object', stat: true, forced: Object.defineProperties !== defineProperties, sham: !DESCRIPTORS }, { + defineProperties: defineProperties +}); + + +/***/ }), +/* 349 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var defineProperty = __webpack_require__(44).f; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +// eslint-disable-next-line es/no-object-defineproperty -- safe +$({ target: 'Object', stat: true, forced: Object.defineProperty !== defineProperty, sham: !DESCRIPTORS }, { + defineProperty: defineProperty +}); + + +/***/ }), +/* 350 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var FORCED = __webpack_require__(347); +var aCallable = __webpack_require__(30); +var toObject = __webpack_require__(39); +var definePropertyModule = __webpack_require__(44); + +// `Object.prototype.__defineSetter__` method +// https://tc39.es/ecma262/#sec-object.prototype.__defineSetter__ +if (DESCRIPTORS) { + $({ target: 'Object', proto: true, forced: FORCED }, { + __defineSetter__: function __defineSetter__(P, setter) { + definePropertyModule.f(toObject(this), P, { set: aCallable(setter), enumerable: true, configurable: true }); + } + }); +} + + +/***/ }), +/* 351 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $entries = __webpack_require__(352).entries; + +// `Object.entries` method +// https://tc39.es/ecma262/#sec-object.entries +$({ target: 'Object', stat: true }, { + entries: function entries(O) { + return $entries(O); + } +}); + + +/***/ }), +/* 352 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var fails = __webpack_require__(7); +var uncurryThis = __webpack_require__(14); +var objectGetPrototypeOf = __webpack_require__(134); +var objectKeys = __webpack_require__(73); +var toIndexedObject = __webpack_require__(12); +var $propertyIsEnumerable = __webpack_require__(10).f; + +var propertyIsEnumerable = uncurryThis($propertyIsEnumerable); +var push = uncurryThis([].push); + +// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys +// of `null` prototype objects +var IE_BUG = DESCRIPTORS && fails(function () { + // eslint-disable-next-line es/no-object-create -- safe + var O = Object.create(null); + O[2] = 2; + return !propertyIsEnumerable(O, 2); +}); + +// `Object.{ entries, values }` methods implementation +var createMethod = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null; + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) { + push(result, TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; +}; + +module.exports = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod(false) +}; + + +/***/ }), +/* 353 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var FREEZING = __webpack_require__(287); +var fails = __webpack_require__(7); +var isObject = __webpack_require__(20); +var onFreeze = __webpack_require__(292).onFreeze; + +// eslint-disable-next-line es/no-object-freeze -- safe +var $freeze = Object.freeze; +var FAILS_ON_PRIMITIVES = fails(function () { $freeze(1); }); + +// `Object.freeze` method +// https://tc39.es/ecma262/#sec-object.freeze +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { + freeze: function freeze(it) { + return $freeze && isObject(it) ? $freeze(onFreeze(it)) : it; + } +}); + + +/***/ }), +/* 354 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var iterate = __webpack_require__(136); +var createProperty = __webpack_require__(90); + +// `Object.fromEntries` method +// https://tc39.es/ecma262/#sec-object.fromentries +$({ target: 'Object', stat: true }, { + fromEntries: function fromEntries(iterable) { + var obj = {}; + iterate(iterable, function (k, v) { + createProperty(obj, k, v); + }, { AS_ENTRIES: true }); + return obj; + } +}); + + +/***/ }), +/* 355 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var toIndexedObject = __webpack_require__(12); +var nativeGetOwnPropertyDescriptor = __webpack_require__(5).f; +var DESCRIPTORS = __webpack_require__(6); + +var FORCED = !DESCRIPTORS || fails(function () { nativeGetOwnPropertyDescriptor(1); }); + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) { + return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key); + } +}); + + +/***/ }), +/* 356 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var ownKeys = __webpack_require__(56); +var toIndexedObject = __webpack_require__(12); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var createProperty = __webpack_require__(90); + +// `Object.getOwnPropertyDescriptors` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors +$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, { + getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) { + var O = toIndexedObject(object); + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + var keys = ownKeys(O); + var result = {}; + var index = 0; + var key, descriptor; + while (keys.length > index) { + descriptor = getOwnPropertyDescriptor(O, key = keys[index++]); + if (descriptor !== undefined) createProperty(result, key, descriptor); + } + return result; + } +}); + + +/***/ }), +/* 357 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var getOwnPropertyNames = __webpack_require__(75).f; + +// eslint-disable-next-line es/no-object-getownpropertynames -- required for testing +var FAILS_ON_PRIMITIVES = fails(function () { return !Object.getOwnPropertyNames(1); }); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + getOwnPropertyNames: getOwnPropertyNames +}); + + +/***/ }), +/* 358 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var toObject = __webpack_require__(39); +var nativeGetPrototypeOf = __webpack_require__(134); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(135); + +var FAILS_ON_PRIMITIVES = fails(function () { nativeGetPrototypeOf(1); }); + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !CORRECT_PROTOTYPE_GETTER }, { + getPrototypeOf: function getPrototypeOf(it) { + return nativeGetPrototypeOf(toObject(it)); + } +}); + + + +/***/ }), +/* 359 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createProperty = __webpack_require__(90); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); +var requireObjectCoercible = __webpack_require__(16); +var toPropertyKey = __webpack_require__(18); +var iterate = __webpack_require__(136); +var fails = __webpack_require__(7); + +// eslint-disable-next-line es/no-object-groupby -- testing +var nativeGroupBy = Object.groupBy; +var create = getBuiltIn('Object', 'create'); +var push = uncurryThis([].push); + +// https://bugs.webkit.org/show_bug.cgi?id=271524 +var DOES_NOT_WORK_WITH_PRIMITIVES = !nativeGroupBy || fails(function () { + return nativeGroupBy('ab', function (it) { + return it; + }).a.length !== 1; +}); + +// `Object.groupBy` method +// https://tc39.es/ecma262/#sec-object.groupby +$({ target: 'Object', stat: true, forced: DOES_NOT_WORK_WITH_PRIMITIVES }, { + groupBy: function groupBy(items, callbackfn) { + requireObjectCoercible(items); + aCallable(callbackfn); + var obj = create(null); + var k = 0; + iterate(items, function (value) { + var key = toPropertyKey(callbackfn(value, k++)); + // in some IE versions, `hasOwnProperty` returns incorrect result on integer keys + // but since it's a `null` prototype object, we can safely use `in` + if (key in obj) push(obj[key], value); + else createProperty(obj, key, [value]); + }); + return obj; + } +}); + + +/***/ }), +/* 360 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var hasOwn = __webpack_require__(38); + +// `Object.hasOwn` method +// https://tc39.es/ecma262/#sec-object.hasown +$({ target: 'Object', stat: true }, { + hasOwn: hasOwn +}); + + +/***/ }), +/* 361 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var is = __webpack_require__(362); + +// `Object.is` method +// https://tc39.es/ecma262/#sec-object.is +$({ target: 'Object', stat: true }, { + is: is +}); + + +/***/ }), +/* 362 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// `SameValue` abstract operation +// https://tc39.es/ecma262/#sec-samevalue +// eslint-disable-next-line es/no-object-is -- safe +module.exports = Object.is || function is(x, y) { + // eslint-disable-next-line no-self-compare -- NaN check + return x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y; +}; + + +/***/ }), +/* 363 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $isExtensible = __webpack_require__(293); + +// `Object.isExtensible` method +// https://tc39.es/ecma262/#sec-object.isextensible +// eslint-disable-next-line es/no-object-isextensible -- safe +$({ target: 'Object', stat: true, forced: Object.isExtensible !== $isExtensible }, { + isExtensible: $isExtensible +}); + + +/***/ }), +/* 364 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var isObject = __webpack_require__(20); +var classof = __webpack_require__(15); +var ARRAY_BUFFER_NON_EXTENSIBLE = __webpack_require__(294); + +// eslint-disable-next-line es/no-object-isfrozen -- safe +var $isFrozen = Object.isFrozen; + +var FORCED = ARRAY_BUFFER_NON_EXTENSIBLE || fails(function () { $isFrozen(1); }); + +// `Object.isFrozen` method +// https://tc39.es/ecma262/#sec-object.isfrozen +$({ target: 'Object', stat: true, forced: FORCED }, { + isFrozen: function isFrozen(it) { + if (!isObject(it)) return true; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return true; + return $isFrozen ? $isFrozen(it) : false; + } +}); + + +/***/ }), +/* 365 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var isObject = __webpack_require__(20); +var classof = __webpack_require__(15); +var ARRAY_BUFFER_NON_EXTENSIBLE = __webpack_require__(294); + +// eslint-disable-next-line es/no-object-issealed -- safe +var $isSealed = Object.isSealed; + +var FORCED = ARRAY_BUFFER_NON_EXTENSIBLE || fails(function () { $isSealed(1); }); + +// `Object.isSealed` method +// https://tc39.es/ecma262/#sec-object.issealed +$({ target: 'Object', stat: true, forced: FORCED }, { + isSealed: function isSealed(it) { + if (!isObject(it)) return true; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return true; + return $isSealed ? $isSealed(it) : false; + } +}); + + +/***/ }), +/* 366 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toObject = __webpack_require__(39); +var nativeKeys = __webpack_require__(73); +var fails = __webpack_require__(7); + +var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); }); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys(toObject(it)); + } +}); + + +/***/ }), +/* 367 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var FORCED = __webpack_require__(347); +var toObject = __webpack_require__(39); +var toPropertyKey = __webpack_require__(18); +var getPrototypeOf = __webpack_require__(134); +var getOwnPropertyDescriptor = __webpack_require__(5).f; + +// `Object.prototype.__lookupGetter__` method +// https://tc39.es/ecma262/#sec-object.prototype.__lookupGetter__ +if (DESCRIPTORS) { + $({ target: 'Object', proto: true, forced: FORCED }, { + __lookupGetter__: function __lookupGetter__(P) { + var O = toObject(this); + var key = toPropertyKey(P); + var desc; + do { + if (desc = getOwnPropertyDescriptor(O, key)) return desc.get; + } while (O = getPrototypeOf(O)); + } + }); +} + + +/***/ }), +/* 368 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var FORCED = __webpack_require__(347); +var toObject = __webpack_require__(39); +var toPropertyKey = __webpack_require__(18); +var getPrototypeOf = __webpack_require__(134); +var getOwnPropertyDescriptor = __webpack_require__(5).f; + +// `Object.prototype.__lookupSetter__` method +// https://tc39.es/ecma262/#sec-object.prototype.__lookupSetter__ +if (DESCRIPTORS) { + $({ target: 'Object', proto: true, forced: FORCED }, { + __lookupSetter__: function __lookupSetter__(P) { + var O = toObject(this); + var key = toPropertyKey(P); + var desc; + do { + if (desc = getOwnPropertyDescriptor(O, key)) return desc.set; + } while (O = getPrototypeOf(O)); + } + }); +} + + +/***/ }), +/* 369 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isObject = __webpack_require__(20); +var onFreeze = __webpack_require__(292).onFreeze; +var FREEZING = __webpack_require__(287); +var fails = __webpack_require__(7); + +// eslint-disable-next-line es/no-object-preventextensions -- safe +var $preventExtensions = Object.preventExtensions; +var FAILS_ON_PRIMITIVES = fails(function () { $preventExtensions(1); }); + +// `Object.preventExtensions` method +// https://tc39.es/ecma262/#sec-object.preventextensions +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { + preventExtensions: function preventExtensions(it) { + return $preventExtensions && isObject(it) ? $preventExtensions(onFreeze(it)) : it; + } +}); + + +/***/ }), +/* 370 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var defineBuiltInAccessor = __webpack_require__(77); +var isObject = __webpack_require__(20); +var isPossiblePrototype = __webpack_require__(121); +var toObject = __webpack_require__(39); +var requireObjectCoercible = __webpack_require__(16); + +// eslint-disable-next-line es/no-object-getprototypeof -- safe +var getPrototypeOf = Object.getPrototypeOf; +// eslint-disable-next-line es/no-object-setprototypeof -- safe +var setPrototypeOf = Object.setPrototypeOf; +var ObjectPrototype = Object.prototype; +var PROTO = '__proto__'; + +// `Object.prototype.__proto__` accessor +// https://tc39.es/ecma262/#sec-object.prototype.__proto__ +if (DESCRIPTORS && getPrototypeOf && setPrototypeOf && !(PROTO in ObjectPrototype)) try { + defineBuiltInAccessor(ObjectPrototype, PROTO, { + configurable: true, + get: function __proto__() { + return getPrototypeOf(toObject(this)); + }, + set: function __proto__(proto) { + var O = requireObjectCoercible(this); + if (isPossiblePrototype(proto) && isObject(O)) { + setPrototypeOf(O, proto); + } + } + }); +} catch (error) { /* empty */ } + + +/***/ }), +/* 371 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isObject = __webpack_require__(20); +var onFreeze = __webpack_require__(292).onFreeze; +var FREEZING = __webpack_require__(287); +var fails = __webpack_require__(7); + +// eslint-disable-next-line es/no-object-seal -- safe +var $seal = Object.seal; +var FAILS_ON_PRIMITIVES = fails(function () { $seal(1); }); + +// `Object.seal` method +// https://tc39.es/ecma262/#sec-object.seal +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, { + seal: function seal(it) { + return $seal && isObject(it) ? $seal(onFreeze(it)) : it; + } +}); + + +/***/ }), +/* 372 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var setPrototypeOf = __webpack_require__(118); + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +$({ target: 'Object', stat: true }, { + setPrototypeOf: setPrototypeOf +}); + + +/***/ }), +/* 373 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(70); +var defineBuiltIn = __webpack_require__(47); +var toString = __webpack_require__(374); + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true }); +} + + +/***/ }), +/* 374 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(70); +var classof = __webpack_require__(69); + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; + + +/***/ }), +/* 375 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $values = __webpack_require__(352).values; + +// `Object.values` method +// https://tc39.es/ecma262/#sec-object.values +$({ target: 'Object', stat: true }, { + values: function values(O) { + return $values(O); + } +}); + + +/***/ }), +/* 376 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $parseFloat = __webpack_require__(337); + +// `parseFloat` method +// https://tc39.es/ecma262/#sec-parsefloat-string +$({ global: true, forced: parseFloat !== $parseFloat }, { + parseFloat: $parseFloat +}); + + +/***/ }), +/* 377 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $parseInt = __webpack_require__(339); + +// `parseInt` method +// https://tc39.es/ecma262/#sec-parseint-string-radix +$({ global: true, forced: parseInt !== $parseInt }, { + parseInt: $parseInt +}); + + +/***/ }), +/* 378 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's split to modules listed below +__webpack_require__(379); +__webpack_require__(395); +__webpack_require__(397); +__webpack_require__(398); +__webpack_require__(399); +__webpack_require__(400); + + +/***/ }), +/* 379 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var IS_PURE = __webpack_require__(36); +var IS_NODE = __webpack_require__(188); +var globalThis = __webpack_require__(4); +var path = __webpack_require__(80); +var call = __webpack_require__(8); +var defineBuiltIn = __webpack_require__(47); +var setPrototypeOf = __webpack_require__(118); +var setToStringTag = __webpack_require__(82); +var setSpecies = __webpack_require__(200); +var aCallable = __webpack_require__(30); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var anInstance = __webpack_require__(215); +var speciesConstructor = __webpack_require__(380); +var task = __webpack_require__(382).set; +var microtask = __webpack_require__(385); +var hostReportErrors = __webpack_require__(390); +var perform = __webpack_require__(391); +var Queue = __webpack_require__(387); +var InternalStateModule = __webpack_require__(51); +var NativePromiseConstructor = __webpack_require__(392); +var PromiseConstructorDetection = __webpack_require__(393); +var newPromiseCapabilityModule = __webpack_require__(394); + +var PROMISE = 'Promise'; +var FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR; +var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; +var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; +var getInternalPromiseState = InternalStateModule.getterFor(PROMISE); +var setInternalState = InternalStateModule.set; +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; +var PromiseConstructor = NativePromiseConstructor; +var PromisePrototype = NativePromisePrototype; +var TypeError = globalThis.TypeError; +var document = globalThis.document; +var process = globalThis.process; +var newPromiseCapability = newPromiseCapabilityModule.f; +var newGenericPromiseCapability = newPromiseCapability; + +var DISPATCH_EVENT = !!(document && document.createEvent && globalThis.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +// helpers +var isThenable = function (it) { + var then; + return isObject(it) && isCallable(then = it.then) ? then : false; +}; + +var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + globalThis.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = globalThis['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call(task, globalThis, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call(task, globalThis, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call(then, value, + bind(internalResolve, wrapper, state), + bind(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED_PROMISE_CONSTRUCTOR) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance(this, PromisePrototype); + aCallable(executor); + call(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind(internalResolve, state), bind(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: null + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind(internalResolve, state); + this.reject = bind(internalReject, state); + }; + + newPromiseCapabilityModule.f = newPromiseCapability = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) { + nativeThen = NativePromisePrototype.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf) { + setPrototypeOf(NativePromisePrototype, PromisePrototype); + } + } +} + +// `Promise` constructor +// https://tc39.es/ecma262/#sec-promise-executor +$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + Promise: PromiseConstructor +}); + +PromiseWrapper = path.Promise; + +setToStringTag(PromiseConstructor, PROMISE, false, true); +setSpecies(PROMISE); + + +/***/ }), +/* 380 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); +var aConstructor = __webpack_require__(381); +var isNullOrUndefined = __webpack_require__(17); +var wellKnownSymbol = __webpack_require__(33); + +var SPECIES = wellKnownSymbol('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +module.exports = function (O, defaultConstructor) { + var C = anObject(O).constructor; + var S; + return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S); +}; + + +/***/ }), +/* 381 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isConstructor = __webpack_require__(89); +var tryToString = __webpack_require__(31); + +var $TypeError = TypeError; + +// `Assert: IsConstructor(argument) is true` +module.exports = function (argument) { + if (isConstructor(argument)) return argument; + throw new $TypeError(tryToString(argument) + ' is not a constructor'); +}; + + +/***/ }), +/* 382 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var apply = __webpack_require__(95); +var bind = __webpack_require__(84); +var isCallable = __webpack_require__(21); +var hasOwn = __webpack_require__(38); +var fails = __webpack_require__(7); +var html = __webpack_require__(74); +var arraySlice = __webpack_require__(76); +var createElement = __webpack_require__(42); +var validateArgumentsLength = __webpack_require__(383); +var IS_IOS = __webpack_require__(384); +var IS_NODE = __webpack_require__(188); + +var set = globalThis.setImmediate; +var clear = globalThis.clearImmediate; +var process = globalThis.process; +var Dispatch = globalThis.Dispatch; +var Function = globalThis.Function; +var MessageChannel = globalThis.MessageChannel; +var String = globalThis.String; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var $location, defer, channel, port; + +fails(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = globalThis.location; +}); + +var run = function (id) { + if (hasOwn(queue, id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var eventListener = function (event) { + run(event.data); +}; + +var globalPostMessageDefer = function (id) { + // old engines have not location.origin + globalThis.postMessage(String(id), $location.protocol + '//' + $location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable(handler) ? handler : Function(handler); + var args = arraySlice(arguments, 1); + queue[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue[id]; + }; + // Node.js 0.8- + if (IS_NODE) { + defer = function (id) { + process.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + globalThis.addEventListener && + isCallable(globalThis.postMessage) && + !globalThis.importScripts && + $location && $location.protocol !== 'file:' && + !fails(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + globalThis.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +module.exports = { + set: set, + clear: clear +}; + + +/***/ }), +/* 383 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $TypeError = TypeError; + +module.exports = function (passed, required) { + if (passed < required) throw new $TypeError('Not enough arguments'); + return passed; +}; + + +/***/ }), +/* 384 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(28); + +module.exports = /ipad|iphone|ipod/i.test(userAgent) && /applewebkit/i.test(userAgent); + + +/***/ }), +/* 385 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var safeGetBuiltIn = __webpack_require__(386); +var bind = __webpack_require__(84); +var macrotask = __webpack_require__(382).set; +var Queue = __webpack_require__(387); +var IS_IOS = __webpack_require__(384); +var IS_IOS_PEBBLE = __webpack_require__(388); +var IS_WEBOS_WEBKIT = __webpack_require__(389); +var IS_NODE = __webpack_require__(188); + +var MutationObserver = globalThis.MutationObserver || globalThis.WebKitMutationObserver; +var document = globalThis.document; +var process = globalThis.process; +var Promise = globalThis.Promise; +var microtask = safeGetBuiltIn('queueMicrotask'); +var notify, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!microtask) { + var queue = new Queue(); + + var flush = function () { + var parent, fn; + if (IS_NODE && (parent = process.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) { + toggle = true; + node = document.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise; + then = bind(promise.then, promise); + notify = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE) { + notify = function () { + process.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind(macrotask, globalThis); + notify = function () { + macrotask(flush); + }; + } + + microtask = function (fn) { + if (!queue.head) notify(); + queue.add(fn); + }; +} + +module.exports = microtask; + + +/***/ }), +/* 386 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var DESCRIPTORS = __webpack_require__(6); + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Avoid NodeJS experimental warning +module.exports = function (name) { + if (!DESCRIPTORS) return globalThis[name]; + var descriptor = getOwnPropertyDescriptor(globalThis, name); + return descriptor && descriptor.value; +}; + + +/***/ }), +/* 387 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var Queue = function () { + this.head = null; + this.tail = null; +}; + +Queue.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } +}; + +module.exports = Queue; + + +/***/ }), +/* 388 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(28); + +module.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined'; + + +/***/ }), +/* 389 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(28); + +module.exports = /web0s(?!.*chrome)/i.test(userAgent); + + +/***/ }), +/* 390 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } +}; + + +/***/ }), +/* 391 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + + +/***/ }), +/* 392 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); + +module.exports = globalThis.Promise; + + +/***/ }), +/* 393 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var NativePromiseConstructor = __webpack_require__(392); +var isCallable = __webpack_require__(21); +var isForced = __webpack_require__(67); +var inspectSource = __webpack_require__(50); +var wellKnownSymbol = __webpack_require__(33); +var ENVIRONMENT = __webpack_require__(189); +var IS_PURE = __webpack_require__(36); +var V8_VERSION = __webpack_require__(27); + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; +var SPECIES = wellKnownSymbol('species'); +var SUBCLASSING = false; +var NATIVE_PROMISE_REJECTION_EVENT = isCallable(globalThis.PromiseRejectionEvent); + +var FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution + if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (ENVIRONMENT === 'BROWSER' || ENVIRONMENT === 'DENO') && !NATIVE_PROMISE_REJECTION_EVENT; +}); + +module.exports = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT, + SUBCLASSING: SUBCLASSING +}; + + +/***/ }), +/* 394 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aCallable = __webpack_require__(30); + +var $TypeError = TypeError; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable(resolve); + this.reject = aCallable(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +module.exports.f = function (C) { + return new PromiseCapability(C); +}; + + +/***/ }), +/* 395 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var newPromiseCapabilityModule = __webpack_require__(394); +var perform = __webpack_require__(391); +var iterate = __webpack_require__(136); +var PROMISE_STATICS_INCORRECT_ITERATION = __webpack_require__(396); + +// `Promise.all` method +// https://tc39.es/ecma262/#sec-promise.all +$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), +/* 396 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var NativePromiseConstructor = __webpack_require__(392); +var checkCorrectnessOfIteration = __webpack_require__(171); +var FORCED_PROMISE_CONSTRUCTOR = __webpack_require__(393).CONSTRUCTOR; + +module.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) { + NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ }); +}); + + +/***/ }), +/* 397 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var IS_PURE = __webpack_require__(36); +var FORCED_PROMISE_CONSTRUCTOR = __webpack_require__(393).CONSTRUCTOR; +var NativePromiseConstructor = __webpack_require__(392); +var getBuiltIn = __webpack_require__(23); +var isCallable = __webpack_require__(21); +var defineBuiltIn = __webpack_require__(47); + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// `Promise.prototype.catch` method +// https://tc39.es/ecma262/#sec-promise.prototype.catch +$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } +}); + +// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` +if (!IS_PURE && isCallable(NativePromiseConstructor)) { + var method = getBuiltIn('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true }); + } +} + + +/***/ }), +/* 398 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var newPromiseCapabilityModule = __webpack_require__(394); +var perform = __webpack_require__(391); +var iterate = __webpack_require__(136); +var PROMISE_STATICS_INCORRECT_ITERATION = __webpack_require__(396); + +// `Promise.race` method +// https://tc39.es/ecma262/#sec-promise.race +$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate(iterable, function (promise) { + call($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), +/* 399 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var newPromiseCapabilityModule = __webpack_require__(394); +var FORCED_PROMISE_CONSTRUCTOR = __webpack_require__(393).CONSTRUCTOR; + +// `Promise.reject` method +// https://tc39.es/ecma262/#sec-promise.reject +$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + var capabilityReject = capability.reject; + capabilityReject(r); + return capability.promise; + } +}); + + +/***/ }), +/* 400 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var IS_PURE = __webpack_require__(36); +var NativePromiseConstructor = __webpack_require__(392); +var FORCED_PROMISE_CONSTRUCTOR = __webpack_require__(393).CONSTRUCTOR; +var promiseResolve = __webpack_require__(401); + +var PromiseConstructorWrapper = getBuiltIn('Promise'); +var CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR; + +// `Promise.resolve` method +// https://tc39.es/ecma262/#sec-promise.resolve +$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x); + } +}); + + +/***/ }), +/* 401 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var newPromiseCapability = __webpack_require__(394); + +module.exports = function (C, x) { + anObject(C); + if (isObject(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + + +/***/ }), +/* 402 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var newPromiseCapabilityModule = __webpack_require__(394); +var perform = __webpack_require__(391); +var iterate = __webpack_require__(136); +var PROMISE_STATICS_INCORRECT_ITERATION = __webpack_require__(396); + +// `Promise.allSettled` method +// https://tc39.es/ecma262/#sec-promise.allsettled +$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call(promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (error) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: error }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), +/* 403 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var getBuiltIn = __webpack_require__(23); +var newPromiseCapabilityModule = __webpack_require__(394); +var perform = __webpack_require__(391); +var iterate = __webpack_require__(136); +var PROMISE_STATICS_INCORRECT_ITERATION = __webpack_require__(396); + +var PROMISE_ANY_ERROR = 'No one promise resolved'; + +// `Promise.any` method +// https://tc39.es/ecma262/#sec-promise.any +$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + any: function any(iterable) { + var C = this; + var AggregateError = getBuiltIn('AggregateError'); + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable(C.resolve); + var errors = []; + var counter = 0; + var remaining = 1; + var alreadyResolved = false; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyRejected = false; + remaining++; + call(promiseResolve, C, promise).then(function (value) { + if (alreadyRejected || alreadyResolved) return; + alreadyResolved = true; + resolve(value); + }, function (error) { + if (alreadyRejected || alreadyResolved) return; + alreadyRejected = true; + errors[index] = error; + --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR)); + }); + }); + --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR)); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), +/* 404 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var IS_PURE = __webpack_require__(36); +var NativePromiseConstructor = __webpack_require__(392); +var fails = __webpack_require__(7); +var getBuiltIn = __webpack_require__(23); +var isCallable = __webpack_require__(21); +var speciesConstructor = __webpack_require__(380); +var promiseResolve = __webpack_require__(401); +var defineBuiltIn = __webpack_require__(47); + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829 +var NON_GENERIC = !!NativePromiseConstructor && fails(function () { + // eslint-disable-next-line unicorn/no-thenable -- required for testing + NativePromisePrototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ }); +}); + +// `Promise.prototype.finally` method +// https://tc39.es/ecma262/#sec-promise.prototype.finally +$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, { + 'finally': function (onFinally) { + var C = speciesConstructor(this, getBuiltIn('Promise')); + var isFunction = isCallable(onFinally); + return this.then( + isFunction ? function (x) { + return promiseResolve(C, onFinally()).then(function () { return x; }); + } : onFinally, + isFunction ? function (e) { + return promiseResolve(C, onFinally()).then(function () { throw e; }); + } : onFinally + ); + } +}); + +// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then` +if (!IS_PURE && isCallable(NativePromiseConstructor)) { + var method = getBuiltIn('Promise').prototype['finally']; + if (NativePromisePrototype['finally'] !== method) { + defineBuiltIn(NativePromisePrototype, 'finally', method, { unsafe: true }); + } +} + + +/***/ }), +/* 405 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var apply = __webpack_require__(95); +var slice = __webpack_require__(76); +var newPromiseCapabilityModule = __webpack_require__(394); +var aCallable = __webpack_require__(30); +var perform = __webpack_require__(391); + +var Promise = globalThis.Promise; + +var ACCEPT_ARGUMENTS = false; +// Avoiding the use of polyfills of the previous iteration of this proposal +// that does not accept arguments of the callback +var FORCED = !Promise || !Promise['try'] || perform(function () { + Promise['try'](function (argument) { + ACCEPT_ARGUMENTS = argument === 8; + }, 8); +}).error || !ACCEPT_ARGUMENTS; + +// `Promise.try` method +// https://tc39.es/ecma262/#sec-promise.try +$({ target: 'Promise', stat: true, forced: FORCED }, { + 'try': function (callbackfn /* , ...args */) { + var args = arguments.length > 1 ? slice(arguments, 1) : []; + var promiseCapability = newPromiseCapabilityModule.f(this); + var result = perform(function () { + return apply(aCallable(callbackfn), undefined, args); + }); + (result.error ? promiseCapability.reject : promiseCapability.resolve)(result.value); + return promiseCapability.promise; + } +}); + + +/***/ }), +/* 406 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var newPromiseCapabilityModule = __webpack_require__(394); + +// `Promise.withResolvers` method +// https://tc39.es/ecma262/#sec-promise.withResolvers +$({ target: 'Promise', stat: true }, { + withResolvers: function withResolvers() { + var promiseCapability = newPromiseCapabilityModule.f(this); + return { + promise: promiseCapability.promise, + resolve: promiseCapability.resolve, + reject: promiseCapability.reject + }; + } +}); + + +/***/ }), +/* 407 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fromAsync = __webpack_require__(408); +var fails = __webpack_require__(7); + +// eslint-disable-next-line es/no-array-fromasync -- safe +var nativeFromAsync = Array.fromAsync; +// https://bugs.webkit.org/show_bug.cgi?id=271703 +var INCORRECT_CONSTRUCTURING = !nativeFromAsync || fails(function () { + var counter = 0; + nativeFromAsync.call(function () { + counter++; + return []; + }, { length: 0 }); + return counter !== 1; +}); + +// `Array.fromAsync` method +// https://tc39.es/ecma262/#sec-array.fromasync +$({ target: 'Array', stat: true, forced: INCORRECT_CONSTRUCTURING }, { + fromAsync: fromAsync +}); + + +/***/ }), +/* 408 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var uncurryThis = __webpack_require__(14); +var isConstructor = __webpack_require__(89); +var getAsyncIterator = __webpack_require__(409); +var getIterator = __webpack_require__(139); +var getIteratorDirect = __webpack_require__(267); +var getIteratorMethod = __webpack_require__(140); +var getMethod = __webpack_require__(29); +var getBuiltIn = __webpack_require__(23); +var getBuiltInPrototypeMethod = __webpack_require__(205); +var wellKnownSymbol = __webpack_require__(33); +var AsyncFromSyncIterator = __webpack_require__(410); +var toArray = __webpack_require__(412).toArray; + +var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator'); +var arrayIterator = uncurryThis(getBuiltInPrototypeMethod('Array', 'values')); +var arrayIteratorNext = uncurryThis(arrayIterator([]).next); + +var safeArrayIterator = function () { + return new SafeArrayIterator(this); +}; + +var SafeArrayIterator = function (O) { + this.iterator = arrayIterator(O); +}; + +SafeArrayIterator.prototype.next = function () { + return arrayIteratorNext(this.iterator); +}; + +// `Array.fromAsync` method implementation +// https://github.com/tc39/proposal-array-from-async +module.exports = function fromAsync(items /* , mapfn = undefined, thisArg = undefined */) { + var C = this; + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var thisArg = argumentsLength > 2 ? arguments[2] : undefined; + return new (getBuiltIn('Promise'))(function (resolve) { + if (mapfn !== undefined) mapfn = bind(mapfn, thisArg); + var usingAsyncIterator = getMethod(items, ASYNC_ITERATOR); + var usingSyncIterator = usingAsyncIterator ? undefined : getIteratorMethod(items) || safeArrayIterator; + var A = isConstructor(C) ? new C() : []; + var iterator = usingAsyncIterator + ? getAsyncIterator(items, usingAsyncIterator) + : new AsyncFromSyncIterator(getIteratorDirect(getIterator(items, usingSyncIterator))); + resolve(toArray(iterator, mapfn, A)); + }); +}; + + +/***/ }), +/* 409 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var AsyncFromSyncIterator = __webpack_require__(410); +var anObject = __webpack_require__(46); +var getIterator = __webpack_require__(139); +var getIteratorDirect = __webpack_require__(267); +var getMethod = __webpack_require__(29); +var wellKnownSymbol = __webpack_require__(33); + +var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator'); + +module.exports = function (it, usingIterator) { + var method = arguments.length < 2 ? getMethod(it, ASYNC_ITERATOR) : usingIterator; + return method ? anObject(call(method, it)) : new AsyncFromSyncIterator(getIteratorDirect(getIterator(it))); +}; + + +/***/ }), +/* 410 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var create = __webpack_require__(71); +var getMethod = __webpack_require__(29); +var defineBuiltIns = __webpack_require__(214); +var InternalStateModule = __webpack_require__(51); +var iteratorClose = __webpack_require__(141); +var getBuiltIn = __webpack_require__(23); +var AsyncIteratorPrototype = __webpack_require__(411); +var createIterResultObject = __webpack_require__(179); + +var Promise = getBuiltIn('Promise'); + +var ASYNC_FROM_SYNC_ITERATOR = 'AsyncFromSyncIterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ASYNC_FROM_SYNC_ITERATOR); + +var asyncFromSyncIteratorContinuation = function (result, resolve, reject, syncIterator, closeOnRejection) { + var done = result.done; + Promise.resolve(result.value).then(function (value) { + resolve(createIterResultObject(value, done)); + }, function (error) { + if (!done && closeOnRejection) { + try { + iteratorClose(syncIterator, 'throw', error); + } catch (error2) { + error = error2; + } + } + + reject(error); + }); +}; + +var AsyncFromSyncIterator = function AsyncIterator(iteratorRecord) { + iteratorRecord.type = ASYNC_FROM_SYNC_ITERATOR; + setInternalState(this, iteratorRecord); +}; + +AsyncFromSyncIterator.prototype = defineBuiltIns(create(AsyncIteratorPrototype), { + next: function next() { + var state = getInternalState(this); + var hasValue = arguments.length > 0; + var value = hasValue ? arguments[0] : undefined; + return new Promise(function (resolve, reject) { + var result = anObject(hasValue ? call(state.next, state.iterator, value) : call(state.next, state.iterator)); + asyncFromSyncIteratorContinuation(result, resolve, reject, state.iterator, true); + }); + }, + 'return': function () { + var state = getInternalState(this); + var iterator = state.iterator; + var hasValue = arguments.length > 0; + var value = hasValue ? arguments[0] : undefined; + return new Promise(function (resolve, reject) { + var $return = getMethod(iterator, 'return'); + if ($return === undefined) return resolve(createIterResultObject(value, true)); + var result = anObject(hasValue ? call($return, iterator, value) : call($return, iterator)); + asyncFromSyncIteratorContinuation(result, resolve, reject, iterator); + }); + }, + 'throw': function () { + var state = getInternalState(this); + var iterator = state.iterator; + var hasValue = arguments.length > 0; + var value = hasValue ? arguments[0] : undefined; + return new Promise(function (resolve, reject) { + var $throw = getMethod(iterator, 'throw'); + if ($throw === undefined) { + try { + iteratorClose(iterator, 'normal'); + } catch (error) { + return reject(error); + } + return reject(new TypeError('The iterator does not provide a throw method')); + } + var result = anObject(hasValue ? call($throw, iterator, value) : call($throw, iterator)); + asyncFromSyncIteratorContinuation(result, resolve, reject, iterator, true); + }); + } +}); + +module.exports = AsyncFromSyncIterator; + + +/***/ }), +/* 411 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var shared = __webpack_require__(35); +var isCallable = __webpack_require__(21); +var create = __webpack_require__(71); +var getPrototypeOf = __webpack_require__(134); +var defineBuiltIn = __webpack_require__(47); +var wellKnownSymbol = __webpack_require__(33); +var IS_PURE = __webpack_require__(36); + +var USE_FUNCTION_CONSTRUCTOR = 'USE_FUNCTION_CONSTRUCTOR'; +var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator'); +var AsyncIterator = globalThis.AsyncIterator; +var PassedAsyncIteratorPrototype = shared.AsyncIteratorPrototype; +var AsyncIteratorPrototype, prototype; + +if (PassedAsyncIteratorPrototype) { + AsyncIteratorPrototype = PassedAsyncIteratorPrototype; +} else if (isCallable(AsyncIterator)) { + AsyncIteratorPrototype = AsyncIterator.prototype; +} else if (shared[USE_FUNCTION_CONSTRUCTOR] || globalThis[USE_FUNCTION_CONSTRUCTOR]) { + try { + // eslint-disable-next-line no-new-func -- we have no alternatives without usage of modern syntax + prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function('return async function*(){}()')()))); + if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype = prototype; + } catch (error) { /* empty */ } +} + +if (!AsyncIteratorPrototype) AsyncIteratorPrototype = {}; +else if (IS_PURE) AsyncIteratorPrototype = create(AsyncIteratorPrototype); + +if (!isCallable(AsyncIteratorPrototype[ASYNC_ITERATOR])) { + defineBuiltIn(AsyncIteratorPrototype, ASYNC_ITERATOR, function () { + return this; + }); +} + +module.exports = AsyncIteratorPrototype; + + +/***/ }), +/* 412 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-async-iterator-helpers +// https://github.com/tc39/proposal-array-from-async +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var doesNotExceedSafeInteger = __webpack_require__(147); +var getBuiltIn = __webpack_require__(23); +var createProperty = __webpack_require__(90); +var setArrayLength = __webpack_require__(148); +var getIteratorDirect = __webpack_require__(267); +var closeAsyncIteration = __webpack_require__(413); + +var createMethod = function (TYPE) { + var IS_TO_ARRAY = TYPE === 0; + var IS_FOR_EACH = TYPE === 1; + var IS_EVERY = TYPE === 2; + var IS_SOME = TYPE === 3; + return function (object, fn, target) { + anObject(object); + var MAPPING = fn !== undefined; + if (MAPPING || !IS_TO_ARRAY) aCallable(fn); + var record = getIteratorDirect(object); + var Promise = getBuiltIn('Promise'); + var iterator = record.iterator; + var next = record.next; + var counter = 0; + + return new Promise(function (resolve, reject) { + var ifAbruptCloseAsyncIterator = function (error) { + closeAsyncIteration(iterator, reject, error, reject); + }; + + var loop = function () { + try { + try { + doesNotExceedSafeInteger(counter); + } catch (error5) { + return ifAbruptCloseAsyncIterator(error5); + } + Promise.resolve(anObject(call(next, iterator))).then(function (step) { + try { + if (anObject(step).done) { + if (IS_TO_ARRAY) { + setArrayLength(target, counter); + resolve(target); + } else resolve(IS_SOME ? false : IS_EVERY || undefined); + } else { + var value = step.value; + try { + if (MAPPING) { + var index = counter++; + var result = fn(value, index); + + var handler = function ($result) { + if (IS_FOR_EACH) { + loop(); + } else if (IS_EVERY) { + $result ? loop() : closeAsyncIteration(iterator, resolve, false, reject); + } else if (IS_TO_ARRAY) { + try { + createProperty(target, index, $result); + loop(); + } catch (error4) { ifAbruptCloseAsyncIterator(error4); } + } else { + $result ? closeAsyncIteration(iterator, resolve, IS_SOME || value, reject) : loop(); + } + }; + + if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator); + else handler(result); + } else { + createProperty(target, counter++, value); + loop(); + } + } catch (error3) { ifAbruptCloseAsyncIterator(error3); } + } + } catch (error2) { reject(error2); } + }, reject); + } catch (error) { reject(error); } + }; + + loop(); + }); + }; +}; + +module.exports = { + // `AsyncIterator.prototype.toArray` / `Array.fromAsync` methods + toArray: createMethod(0), + // `AsyncIterator.prototype.forEach` method + forEach: createMethod(1), + // `AsyncIterator.prototype.every` method + every: createMethod(2), + // `AsyncIterator.prototype.some` method + some: createMethod(3), + // `AsyncIterator.prototype.find` method + find: createMethod(4) +}; + + +/***/ }), +/* 413 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getBuiltIn = __webpack_require__(23); +var getMethod = __webpack_require__(29); + +module.exports = function (iterator, method, argument, reject) { + try { + var returnMethod = getMethod(iterator, 'return'); + if (returnMethod) { + return getBuiltIn('Promise').resolve(call(returnMethod, iterator)).then(function (result) { + try { + if (method !== reject) anObject(result); + } catch (error3) { + reject(error3); + return; + } + method(argument); + }, function (error) { + method === reject ? method(argument) : reject(error); + }); + } + } catch (error2) { + // the original error (`argument`) takes priority over `return()` errors + return method === reject ? reject(argument) : reject(error2); + } method(argument); +}; + + +/***/ }), +/* 414 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-async-explicit-resource-management +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var getBuiltIn = __webpack_require__(23); +var aCallable = __webpack_require__(30); +var anInstance = __webpack_require__(215); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltIns = __webpack_require__(214); +var defineBuiltInAccessor = __webpack_require__(77); +var wellKnownSymbol = __webpack_require__(33); +var InternalStateModule = __webpack_require__(51); +var addDisposableResource = __webpack_require__(254); +var V8_VERSION = __webpack_require__(27); + +var Promise = getBuiltIn('Promise'); +var SuppressedError = getBuiltIn('SuppressedError'); +var $ReferenceError = ReferenceError; + +var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose'); +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +var ASYNC_DISPOSABLE_STACK = 'AsyncDisposableStack'; +var setInternalState = InternalStateModule.set; +var getAsyncDisposableStackInternalState = InternalStateModule.getterFor(ASYNC_DISPOSABLE_STACK); + +var HINT = 'async-dispose'; +var DISPOSED = 'disposed'; +var PENDING = 'pending'; + +var getPendingAsyncDisposableStackInternalState = function (stack) { + var internalState = getAsyncDisposableStackInternalState(stack); + if (internalState.state === DISPOSED) throw new $ReferenceError(ASYNC_DISPOSABLE_STACK + ' already disposed'); + return internalState; +}; + +var $AsyncDisposableStack = function AsyncDisposableStack() { + setInternalState(anInstance(this, AsyncDisposableStackPrototype), { + type: ASYNC_DISPOSABLE_STACK, + state: PENDING, + stack: [] + }); + + if (!DESCRIPTORS) this.disposed = false; +}; + +var AsyncDisposableStackPrototype = $AsyncDisposableStack.prototype; + +defineBuiltIns(AsyncDisposableStackPrototype, { + disposeAsync: function disposeAsync() { + var asyncDisposableStack = this; + return new Promise(function (resolve, reject) { + var internalState = getAsyncDisposableStackInternalState(asyncDisposableStack); + if (internalState.state === DISPOSED) return resolve(undefined); + internalState.state = DISPOSED; + if (!DESCRIPTORS) asyncDisposableStack.disposed = true; + var stack = internalState.stack; + var i = stack.length; + var thrown = false; + var suppressed; + + var handleError = function (result) { + if (thrown) { + suppressed = new SuppressedError(result, suppressed); + } else { + thrown = true; + suppressed = result; + } + + loop(); + }; + + var loop = function () { + if (i) { + var disposeMethod = stack[--i]; + stack[i] = null; + try { + Promise.resolve(disposeMethod()).then(loop, handleError); + } catch (error) { + handleError(error); + } + } else { + internalState.stack = null; + thrown ? reject(suppressed) : resolve(undefined); + } + }; + + loop(); + }); + }, + use: function use(value) { + addDisposableResource(getPendingAsyncDisposableStackInternalState(this), value, HINT); + return value; + }, + adopt: function adopt(value, onDispose) { + var internalState = getPendingAsyncDisposableStackInternalState(this); + aCallable(onDispose); + addDisposableResource(internalState, undefined, HINT, function () { + return onDispose(value); + }); + return value; + }, + defer: function defer(onDispose) { + var internalState = getPendingAsyncDisposableStackInternalState(this); + aCallable(onDispose); + addDisposableResource(internalState, undefined, HINT, onDispose); + }, + move: function move() { + var internalState = getPendingAsyncDisposableStackInternalState(this); + var newAsyncDisposableStack = new $AsyncDisposableStack(); + getAsyncDisposableStackInternalState(newAsyncDisposableStack).stack = internalState.stack; + internalState.stack = []; + internalState.state = DISPOSED; + if (!DESCRIPTORS) this.disposed = true; + return newAsyncDisposableStack; + } +}); + +if (DESCRIPTORS) defineBuiltInAccessor(AsyncDisposableStackPrototype, 'disposed', { + configurable: true, + get: function disposed() { + return getAsyncDisposableStackInternalState(this).state === DISPOSED; + } +}); + +defineBuiltIn(AsyncDisposableStackPrototype, ASYNC_DISPOSE, AsyncDisposableStackPrototype.disposeAsync, { name: 'disposeAsync' }); +defineBuiltIn(AsyncDisposableStackPrototype, TO_STRING_TAG, ASYNC_DISPOSABLE_STACK, { nonWritable: true }); + +// https://github.com/tc39/proposal-explicit-resource-management/issues/256 +// can't be detected synchronously +var SYNC_DISPOSE_RETURNING_PROMISE_RESOLUTION_BUG = V8_VERSION && V8_VERSION < 136; + +$({ global: true, constructor: true, forced: SYNC_DISPOSE_RETURNING_PROMISE_RESOLUTION_BUG }, { + AsyncDisposableStack: $AsyncDisposableStack +}); + + +/***/ }), +/* 415 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-async-explicit-resource-management +var call = __webpack_require__(8); +var defineBuiltIn = __webpack_require__(47); +var getBuiltIn = __webpack_require__(23); +var getMethod = __webpack_require__(29); +var hasOwn = __webpack_require__(38); +var wellKnownSymbol = __webpack_require__(33); +var AsyncIteratorPrototype = __webpack_require__(411); + +var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose'); +var Promise = getBuiltIn('Promise'); + +if (!hasOwn(AsyncIteratorPrototype, ASYNC_DISPOSE)) { + defineBuiltIn(AsyncIteratorPrototype, ASYNC_DISPOSE, function () { + var O = this; + return new Promise(function (resolve, reject) { + var $return = getMethod(O, 'return'); + if ($return) { + Promise.resolve(call($return, O)).then(function () { + resolve(undefined); + }, reject); + } else resolve(undefined); + }); + }); +} + + +/***/ }), +/* 416 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var functionApply = __webpack_require__(95); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var fails = __webpack_require__(7); + +// MS Edge argumentsList argument is optional +var OPTIONAL_ARGUMENTS_LIST = !fails(function () { + // eslint-disable-next-line es/no-reflect -- required for testing + Reflect.apply(function () { /* empty */ }); +}); + +// `Reflect.apply` method +// https://tc39.es/ecma262/#sec-reflect.apply +$({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, { + apply: function apply(target, thisArgument, argumentsList) { + return functionApply(aCallable(target), thisArgument, anObject(argumentsList)); + } +}); + + +/***/ }), +/* 417 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var apply = __webpack_require__(95); +var bind = __webpack_require__(257); +var aConstructor = __webpack_require__(381); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var create = __webpack_require__(71); +var fails = __webpack_require__(7); + +var nativeConstruct = getBuiltIn('Reflect', 'construct'); +var ObjectPrototype = Object.prototype; +var push = [].push; + +// `Reflect.construct` method +// https://tc39.es/ecma262/#sec-reflect.construct +// MS Edge supports only 2 arguments and argumentsList argument is optional +// FF Nightly sets third argument as `new.target`, but does not create `this` from it +var NEW_TARGET_BUG = fails(function () { + function F() { /* empty */ } + return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F); +}); + +var ARGS_BUG = !fails(function () { + nativeConstruct(function () { /* empty */ }); +}); + +var FORCED = NEW_TARGET_BUG || ARGS_BUG; + +$({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, { + construct: function construct(Target, args /* , newTarget */) { + aConstructor(Target); + var newTarget = arguments.length < 3 ? Target : aConstructor(arguments[2]); + anObject(args); + if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget); + if (Target === newTarget) { + // w/o altered newTarget, optimization for 0-4 arguments + switch (args.length) { + case 0: return new Target(); + case 1: return new Target(args[0]); + case 2: return new Target(args[0], args[1]); + case 3: return new Target(args[0], args[1], args[2]); + case 4: return new Target(args[0], args[1], args[2], args[3]); + } + // w/o altered newTarget, lot of arguments case + var $args = [null]; + apply(push, $args, args); + return new (apply(bind, Target, $args))(); + } + // with altered newTarget, not support built-in constructors + var proto = newTarget.prototype; + var instance = create(isObject(proto) ? proto : ObjectPrototype); + var result = apply(Target, instance, args); + return isObject(result) ? result : instance; + } +}); + + +/***/ }), +/* 418 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var anObject = __webpack_require__(46); +var toPropertyKey = __webpack_require__(18); +var definePropertyModule = __webpack_require__(44); +var isCallable = __webpack_require__(21); +var fails = __webpack_require__(7); + +var $TypeError = TypeError; + +// MS Edge has broken Reflect.defineProperty - throwing instead of returning false +var ERROR_INSTEAD_OF_FALSE = fails(function () { + // eslint-disable-next-line es/no-reflect -- required for testing + Reflect.defineProperty(definePropertyModule.f({}, 1, { value: 1 }), 1, { value: 2 }); +}); + +// `Reflect.defineProperty` method +// https://tc39.es/ecma262/#sec-reflect.defineproperty +$({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !DESCRIPTORS }, { + defineProperty: function defineProperty(target, propertyKey, attributes) { + anObject(target); + var key = toPropertyKey(propertyKey); + var get, set; + anObject(attributes); + // propagate `ToPropertyDescriptor` errors instead of catching them + if (('get' in attributes || 'set' in attributes) && ( + ('get' in attributes && !isCallable(get = attributes.get) && get !== undefined) || + ('set' in attributes && !isCallable(set = attributes.set) && set !== undefined) || + ('value' in attributes || 'writable' in attributes) + )) throw new $TypeError('Invalid property descriptor'); + try { + definePropertyModule.f(target, key, attributes); + return true; + } catch (error) { + return false; + } + } +}); + + +/***/ }), +/* 419 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var toPropertyKey = __webpack_require__(18); + +// `Reflect.deleteProperty` method +// https://tc39.es/ecma262/#sec-reflect.deleteproperty +$({ target: 'Reflect', stat: true }, { + deleteProperty: function deleteProperty(target, propertyKey) { + anObject(target); + var key = toPropertyKey(propertyKey); + var descriptor = getOwnPropertyDescriptor(target, key); + return descriptor && !descriptor.configurable ? false : delete target[key]; + } +}); + + +/***/ }), +/* 420 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var isObject = __webpack_require__(20); +var anObject = __webpack_require__(46); +var isDataDescriptor = __webpack_require__(421); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var getPrototypeOf = __webpack_require__(134); +var toPropertyKey = __webpack_require__(18); + +// `Reflect.get` method +// https://tc39.es/ecma262/#sec-reflect.get +var $get = function (target, propertyKey, receiver) { + if (anObject(target) === receiver) return target[propertyKey]; + var descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey); + if (descriptor) return isDataDescriptor(descriptor) + ? descriptor.value + : descriptor.get === undefined ? undefined : call(descriptor.get, receiver); + var prototype = getPrototypeOf(target); + if (isObject(prototype)) return $get(prototype, propertyKey, receiver); +}; + +$({ target: 'Reflect', stat: true }, { + get: function get(target, propertyKey /* , receiver */) { + return $get(anObject(target), toPropertyKey(propertyKey), arguments.length < 3 ? target : arguments[2]); + } +}); + + +/***/ }), +/* 421 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(38); + +module.exports = function (descriptor) { + return descriptor !== undefined && (hasOwn(descriptor, 'value') || hasOwn(descriptor, 'writable')); +}; + + +/***/ }), +/* 422 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var anObject = __webpack_require__(46); +var getOwnPropertyDescriptorModule = __webpack_require__(5); + +// `Reflect.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-reflect.getownpropertydescriptor +$({ target: 'Reflect', stat: true, sham: !DESCRIPTORS }, { + getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) { + return getOwnPropertyDescriptorModule.f(anObject(target), propertyKey); + } +}); + + +/***/ }), +/* 423 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var objectGetPrototypeOf = __webpack_require__(134); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(135); + +// `Reflect.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-reflect.getprototypeof +$({ target: 'Reflect', stat: true, sham: !CORRECT_PROTOTYPE_GETTER }, { + getPrototypeOf: function getPrototypeOf(target) { + return objectGetPrototypeOf(anObject(target)); + } +}); + + +/***/ }), +/* 424 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Reflect.has` method +// https://tc39.es/ecma262/#sec-reflect.has +$({ target: 'Reflect', stat: true }, { + has: function has(target, propertyKey) { + return propertyKey in target; + } +}); + + +/***/ }), +/* 425 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var $isExtensible = __webpack_require__(293); + +// `Reflect.isExtensible` method +// https://tc39.es/ecma262/#sec-reflect.isextensible +$({ target: 'Reflect', stat: true }, { + isExtensible: function isExtensible(target) { + anObject(target); + return $isExtensible(target); + } +}); + + +/***/ }), +/* 426 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var ownKeys = __webpack_require__(56); + +// `Reflect.ownKeys` method +// https://tc39.es/ecma262/#sec-reflect.ownkeys +$({ target: 'Reflect', stat: true }, { + ownKeys: ownKeys +}); + + +/***/ }), +/* 427 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var anObject = __webpack_require__(46); +var FREEZING = __webpack_require__(287); + +// `Reflect.preventExtensions` method +// https://tc39.es/ecma262/#sec-reflect.preventextensions +$({ target: 'Reflect', stat: true, sham: !FREEZING }, { + preventExtensions: function preventExtensions(target) { + anObject(target); + try { + var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions'); + if (objectPreventExtensions) objectPreventExtensions(target); + return true; + } catch (error) { + return false; + } + } +}); + + +/***/ }), +/* 428 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var isDataDescriptor = __webpack_require__(421); +var fails = __webpack_require__(7); +var definePropertyModule = __webpack_require__(44); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var getPrototypeOf = __webpack_require__(134); +var createPropertyDescriptor = __webpack_require__(11); +var toPropertyKey = __webpack_require__(18); + +// `Reflect.set` method +// https://tc39.es/ecma262/#sec-reflect.set +var $set = function (target, propertyKey, V, receiver) { + var ownDescriptor = getOwnPropertyDescriptorModule.f(anObject(target), propertyKey); + var existingDescriptor, prototype, setter; + if (!ownDescriptor) { + if (isObject(prototype = getPrototypeOf(target))) { + return $set(prototype, propertyKey, V, receiver); + } + ownDescriptor = createPropertyDescriptor(0); + } + if (isDataDescriptor(ownDescriptor)) { + if (ownDescriptor.writable === false || !isObject(receiver)) return false; + if (existingDescriptor = getOwnPropertyDescriptorModule.f(receiver, propertyKey)) { + if (!isDataDescriptor(existingDescriptor) || existingDescriptor.writable === false) return false; + definePropertyModule.f(receiver, propertyKey, { value: V }); + } else try { + definePropertyModule.f(receiver, propertyKey, createPropertyDescriptor(0, V)); + } catch (error) { + return false; + } + } else { + setter = ownDescriptor.set; + if (setter === undefined) return false; + call(setter, receiver, V); + } return true; +}; + +// MS Edge 17-18 Reflect.set allows setting the property to object +// with non-writable property on the prototype +var MS_EDGE_BUG = fails(function () { + var Constructor = function () { /* empty */ }; + var object = definePropertyModule.f(new Constructor(), 'a', { configurable: true }); + // eslint-disable-next-line es/no-reflect -- required for testing + return Reflect.set(Constructor.prototype, 'a', 1, object) !== false; +}); + +$({ target: 'Reflect', stat: true, forced: MS_EDGE_BUG }, { + set: function set(target, propertyKey, V /* , receiver */) { + return $set(anObject(target), toPropertyKey(propertyKey), V, arguments.length < 4 ? target : arguments[3]); + } +}); + + +/***/ }), +/* 429 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var aPossiblePrototype = __webpack_require__(120); +var objectSetPrototypeOf = __webpack_require__(118); + +// `Reflect.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-reflect.setprototypeof +if (objectSetPrototypeOf) $({ target: 'Reflect', stat: true }, { + setPrototypeOf: function setPrototypeOf(target, proto) { + anObject(target); + aPossiblePrototype(proto); + try { + objectSetPrototypeOf(target, proto); + return true; + } catch (error) { + return false; + } + } +}); + + +/***/ }), +/* 430 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var setToStringTag = __webpack_require__(82); + +$({ global: true }, { Reflect: {} }); + +// Reflect[@@toStringTag] property +// https://tc39.es/ecma262/#sec-reflect-@@tostringtag +setToStringTag(globalThis.Reflect, 'Reflect', true); + + +/***/ }), +/* 431 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var isForced = __webpack_require__(67); +var inheritIfRequired = __webpack_require__(123); +var createNonEnumerableProperty = __webpack_require__(43); +var create = __webpack_require__(71); +var getOwnPropertyNames = __webpack_require__(57).f; +var isPrototypeOf = __webpack_require__(24); +var isRegExp = __webpack_require__(432); +var toString = __webpack_require__(68); +var getRegExpFlags = __webpack_require__(433); +var stickyHelpers = __webpack_require__(436); +var proxyAccessor = __webpack_require__(122); +var defineBuiltIn = __webpack_require__(47); +var fails = __webpack_require__(7); +var hasOwn = __webpack_require__(38); +var enforceInternalState = __webpack_require__(51).enforce; +var setSpecies = __webpack_require__(200); +var wellKnownSymbol = __webpack_require__(33); +var UNSUPPORTED_DOT_ALL = __webpack_require__(437); +var UNSUPPORTED_NCG = __webpack_require__(438); + +var MATCH = wellKnownSymbol('match'); +var NativeRegExp = globalThis.RegExp; +var RegExpPrototype = NativeRegExp.prototype; +var SyntaxError = globalThis.SyntaxError; +var exec = uncurryThis(RegExpPrototype.exec); +var charAt = uncurryThis(''.charAt); +var replace = uncurryThis(''.replace); +var stringIndexOf = uncurryThis(''.indexOf); +var stringSlice = uncurryThis(''.slice); +// TODO: Use only proper RegExpIdentifierName +var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/; +var re1 = /a/g; +var re2 = /a/g; + +// "new" should create a new object, old webkit bug +var CORRECT_NEW = new NativeRegExp(re1) !== re1; + +var MISSED_STICKY = stickyHelpers.MISSED_STICKY; +var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y; + +var BASE_FORCED = DESCRIPTORS && + (!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails(function () { + re2[MATCH] = false; + // RegExp constructor can alter flags and IsRegExp works correct with @@match + // eslint-disable-next-line sonarjs/inconsistent-function-call -- required for testing + return NativeRegExp(re1) !== re1 || NativeRegExp(re2) === re2 || String(NativeRegExp(re1, 'i')) !== '/a/i'; + })); + +var handleDotAll = function (string) { + var length = string.length; + var index = 0; + var result = ''; + var brackets = false; + var chr; + for (; index < length; index++) { + chr = charAt(string, index); + if (chr === '\\') { + result += chr + charAt(string, ++index); + continue; + } + if (!brackets && chr === '.') { + result += '[\\s\\S]'; + } else { + if (chr === '[') { + brackets = true; + } else if (chr === ']') { + brackets = false; + } result += chr; + } + } return result; +}; + +var handleNCG = function (string) { + var length = string.length; + var index = 0; + var result = ''; + var named = []; + var names = create(null); + var brackets = false; + var ncg = false; + var groupid = 0; + var groupname = ''; + var chr; + for (; index < length; index++) { + chr = charAt(string, index); + if (chr === '\\') { + chr += charAt(string, ++index); + // use `\x5c` for escaped backslash to avoid corruption by `\k` to `\N` replacement below + if (!ncg && charAt(chr, 1) === '\\') { + result += '\\x5c'; + continue; + } + } else if (chr === ']') { + brackets = false; + } else if (!brackets) switch (true) { + case chr === '[': + brackets = true; + break; + case chr === '(': + result += chr; + if (exec(IS_NCG, stringSlice(string, index + 1))) { + index += 2; + ncg = true; + groupid++; + } else if (charAt(string, index + 1) !== '?') { + groupid++; + } + continue; + case chr === '>' && ncg: + if (groupname === '' || hasOwn(names, groupname)) { + throw new SyntaxError('Invalid capture group name'); + } + names[groupname] = true; + named[named.length] = [groupname, groupid]; + ncg = false; + groupname = ''; + continue; + } + if (ncg) groupname += chr; + else result += chr; + } + // convert `\k` backreferences to numbered backreferences + for (var ni = 0; ni < named.length; ni++) { + var backref = '\\k<' + named[ni][0] + '>'; + var numRef = '\\' + named[ni][1]; + while (stringIndexOf(result, backref) > -1) { + result = replace(result, backref, numRef); + } + } return [result, named]; +}; + +// `RegExp` constructor +// https://tc39.es/ecma262/#sec-regexp-constructor +if (isForced('RegExp', BASE_FORCED)) { + var RegExpWrapper = function RegExp(pattern, flags) { + var thisIsRegExp = isPrototypeOf(RegExpPrototype, this); + var patternIsRegExp = isRegExp(pattern); + var flagsAreUndefined = flags === undefined; + var groups = []; + var rawPattern = pattern; + var rawFlags, dotAll, sticky, handled, result, state; + + if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) { + return pattern; + } + + if (patternIsRegExp || isPrototypeOf(RegExpPrototype, pattern)) { + pattern = pattern.source; + if (flagsAreUndefined) flags = getRegExpFlags(rawPattern); + } + + pattern = pattern === undefined ? '' : toString(pattern); + flags = flags === undefined ? '' : toString(flags); + rawPattern = pattern; + + if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) { + dotAll = !!flags && stringIndexOf(flags, 's') > -1; + if (dotAll) flags = replace(flags, /s/g, ''); + } + + rawFlags = flags; + + if (MISSED_STICKY && 'sticky' in re1) { + sticky = !!flags && stringIndexOf(flags, 'y') > -1; + if (sticky && UNSUPPORTED_Y) flags = replace(flags, /y/g, ''); + } + + if (UNSUPPORTED_NCG) { + handled = handleNCG(pattern); + pattern = handled[0]; + groups = handled[1]; + } + + result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype, RegExpWrapper); + + if (dotAll || sticky || groups.length) { + state = enforceInternalState(result); + if (dotAll) { + state.dotAll = true; + state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags); + } + if (sticky) state.sticky = true; + if (groups.length) state.groups = groups; + } + + if (pattern !== rawPattern) try { + // fails in old engines, but we have no alternatives for unsupported regex syntax + createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern); + } catch (error) { /* empty */ } + + return result; + }; + + for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) { + proxyAccessor(RegExpWrapper, NativeRegExp, keys[index++]); + } + + RegExpPrototype.constructor = RegExpWrapper; + RegExpWrapper.prototype = RegExpPrototype; + defineBuiltIn(globalThis, 'RegExp', RegExpWrapper, { constructor: true }); +} + +// https://tc39.es/ecma262/#sec-get-regexp-@@species +setSpecies('RegExp'); + + +/***/ }), +/* 432 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); +var classof = __webpack_require__(15); +var wellKnownSymbol = __webpack_require__(33); + +var MATCH = wellKnownSymbol('match'); + +// `IsRegExp` abstract operation +// https://tc39.es/ecma262/#sec-isregexp +module.exports = function (it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp'); +}; + + +/***/ }), +/* 433 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var hasOwn = __webpack_require__(38); +var isPrototypeOf = __webpack_require__(24); +var regExpFlagsDetection = __webpack_require__(434); +var regExpFlagsGetterImplementation = __webpack_require__(435); + +var RegExpPrototype = RegExp.prototype; + +module.exports = regExpFlagsDetection.correct ? function (it) { + return it.flags; +} : function (it) { + return (!regExpFlagsDetection.correct && isPrototypeOf(RegExpPrototype, it) && !hasOwn(it, 'flags')) + ? call(regExpFlagsGetterImplementation, it) + : it.flags; +}; + + +/***/ }), +/* 434 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); + +// babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError +var RegExp = globalThis.RegExp; + +var FLAGS_GETTER_IS_CORRECT = !fails(function () { + var INDICES_SUPPORT = true; + try { + RegExp('.', 'd'); + } catch (error) { + INDICES_SUPPORT = false; + } + + var O = {}; + // modern V8 bug + var calls = ''; + var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy'; + + var addGetter = function (key, chr) { + // eslint-disable-next-line es/no-object-defineproperty -- safe + Object.defineProperty(O, key, { get: function () { + calls += chr; + return true; + } }); + }; + + var pairs = { + dotAll: 's', + global: 'g', + ignoreCase: 'i', + multiline: 'm', + sticky: 'y' + }; + + if (INDICES_SUPPORT) pairs.hasIndices = 'd'; + + for (var key in pairs) addGetter(key, pairs[key]); + + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var result = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get.call(O); + + return result !== expected || calls !== expected; +}); + +module.exports = { correct: FLAGS_GETTER_IS_CORRECT }; + + +/***/ }), +/* 435 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); + +// `RegExp.prototype.flags` getter implementation +// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags +module.exports = function () { + var that = anObject(this); + var result = ''; + if (that.hasIndices) result += 'd'; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.dotAll) result += 's'; + if (that.unicode) result += 'u'; + if (that.unicodeSets) result += 'v'; + if (that.sticky) result += 'y'; + return result; +}; + + +/***/ }), +/* 436 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var globalThis = __webpack_require__(4); + +// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError +var $RegExp = globalThis.RegExp; + +var UNSUPPORTED_Y = fails(function () { + var re = $RegExp('a', 'y'); + re.lastIndex = 2; + return re.exec('abcd') !== null; +}); + +// UC Browser bug +// https://github.com/zloirock/core-js/issues/1008 +var MISSED_STICKY = UNSUPPORTED_Y || fails(function () { + return !$RegExp('a', 'y').sticky; +}); + +var BROKEN_CARET = UNSUPPORTED_Y || fails(function () { + // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 + var re = $RegExp('^r', 'gy'); + re.lastIndex = 2; + return re.exec('str') !== null; +}); + +module.exports = { + BROKEN_CARET: BROKEN_CARET, + MISSED_STICKY: MISSED_STICKY, + UNSUPPORTED_Y: UNSUPPORTED_Y +}; + + +/***/ }), +/* 437 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var globalThis = __webpack_require__(4); + +// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError +var $RegExp = globalThis.RegExp; + +module.exports = fails(function () { + var re = $RegExp('.', 's'); + return !(re.dotAll && re.test('\n') && re.flags === 's'); +}); + + +/***/ }), +/* 438 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var globalThis = __webpack_require__(4); + +// babel-minify and Closure Compiler transpiles RegExp('(?b)', 'g') -> /(?b)/g and it causes SyntaxError +var $RegExp = globalThis.RegExp; + +module.exports = fails(function () { + var re = $RegExp('(?b)', 'g'); + return re.exec('b').groups.a !== 'b' || + 'b'.replace(re, '$c') !== 'bc'; +}); + + +/***/ }), +/* 439 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aString = __webpack_require__(440); +var hasOwn = __webpack_require__(38); +var padStart = __webpack_require__(247).start; +var WHITESPACES = __webpack_require__(326); + +var $Array = Array; +var $escape = RegExp.escape; +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var numberToString = uncurryThis(1.1.toString); +var join = uncurryThis([].join); +var FIRST_DIGIT_OR_ASCII = /^[0-9a-z]/i; +var SYNTAX_SOLIDUS = /^[$()*+./?[\\\]^{|}]/; +var OTHER_PUNCTUATORS_AND_WHITESPACES = RegExp('^[!"#%&\',\\-:;<=>@`~' + WHITESPACES + ']'); +var exec = uncurryThis(FIRST_DIGIT_OR_ASCII.exec); + +var ControlEscape = { + '\u0009': 't', + '\u000A': 'n', + '\u000B': 'v', + '\u000C': 'f', + '\u000D': 'r' +}; + +var escapeChar = function (chr) { + var hex = numberToString(charCodeAt(chr, 0), 16); + return hex.length < 3 ? '\\x' + padStart(hex, 2, '0') : '\\u' + padStart(hex, 4, '0'); +}; + +// Avoiding the use of polyfills of the previous iteration of this proposal +var FORCED = !$escape || $escape('ab') !== '\\x61b'; + +// `RegExp.escape` method +// https://tc39.es/ecma262/#sec-regexp.escape +$({ target: 'RegExp', stat: true, forced: FORCED }, { + escape: function escape(S) { + aString(S); + var length = S.length; + var result = $Array(length); + + for (var i = 0; i < length; i++) { + var chr = charAt(S, i); + if (i === 0 && exec(FIRST_DIGIT_OR_ASCII, chr)) { + result[i] = escapeChar(chr); + } else if (hasOwn(ControlEscape, chr)) { + result[i] = '\\' + ControlEscape[chr]; + } else if (exec(SYNTAX_SOLIDUS, chr)) { + result[i] = '\\' + chr; + } else if (exec(OTHER_PUNCTUATORS_AND_WHITESPACES, chr)) { + result[i] = escapeChar(chr); + } else { + var charCode = charCodeAt(chr, 0); + // single UTF-16 code unit + if ((charCode & 0xF800) !== 0xD800) result[i] = chr; + // unpaired surrogate + else if (charCode >= 0xDC00 || i + 1 >= length || (charCodeAt(S, i + 1) & 0xFC00) !== 0xDC00) result[i] = escapeChar(chr); + // surrogate pair + else { + result[i] = chr; + result[++i] = charAt(S, i); + } + } + } + + return join(result, ''); + } +}); + + +/***/ }), +/* 440 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $TypeError = TypeError; + +module.exports = function (argument) { + if (typeof argument == 'string') return argument; + throw new $TypeError('Argument is not a string'); +}; + + +/***/ }), +/* 441 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var UNSUPPORTED_DOT_ALL = __webpack_require__(437); +var classof = __webpack_require__(15); +var defineBuiltInAccessor = __webpack_require__(77); +var getInternalState = __webpack_require__(51).get; + +var RegExpPrototype = RegExp.prototype; +var $TypeError = TypeError; + +// `RegExp.prototype.dotAll` getter +// https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall +if (DESCRIPTORS && UNSUPPORTED_DOT_ALL) { + defineBuiltInAccessor(RegExpPrototype, 'dotAll', { + configurable: true, + get: function dotAll() { + if (this === RegExpPrototype) return; + // We can't use InternalStateModule.getterFor because + // we don't add metadata for regexps created by a literal. + if (classof(this) === 'RegExp') { + return !!getInternalState(this).dotAll; + } + throw new $TypeError('Incompatible receiver, RegExp required'); + } + }); +} + + +/***/ }), +/* 442 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var exec = __webpack_require__(443); + +// `RegExp.prototype.exec` method +// https://tc39.es/ecma262/#sec-regexp.prototype.exec +$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, { + exec: exec +}); + + +/***/ }), +/* 443 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */ +/* eslint-disable regexp/no-useless-quantifier -- testing */ +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); +var regexpFlags = __webpack_require__(435); +var stickyHelpers = __webpack_require__(436); +var shared = __webpack_require__(34); +var create = __webpack_require__(71); +var getInternalState = __webpack_require__(51).get; +var UNSUPPORTED_DOT_ALL = __webpack_require__(437); +var UNSUPPORTED_NCG = __webpack_require__(438); + +var nativeReplace = shared('native-string-replace', String.prototype.replace); +var nativeExec = RegExp.prototype.exec; +var patchedExec = nativeExec; +var charAt = uncurryThis(''.charAt); +var indexOf = uncurryThis(''.indexOf); +var replace = uncurryThis(''.replace); +var stringSlice = uncurryThis(''.slice); + +var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/; + var re2 = /b*/g; + call(nativeExec, re1, 'a'); + call(nativeExec, re2, 'a'); + return re1.lastIndex !== 0 || re2.lastIndex !== 0; +})(); + +var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET; + +// nonparticipating capturing group, copied from es5-shim's String#split patch. +var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + +var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG; + +var setGroups = function (re, groups) { + var object = re.groups = create(null); + for (var i = 0; i < groups.length; i++) { + var group = groups[i]; + object[group[0]] = re[group[1]]; + } +}; + +if (PATCH) { + patchedExec = function exec(string) { + var re = this; + var state = getInternalState(re); + var str = toString(string); + var raw = state.raw; + var result, reCopy, lastIndex; + + if (raw) { + raw.lastIndex = re.lastIndex; + result = call(patchedExec, raw, str); + re.lastIndex = raw.lastIndex; + + if (result && state.groups) setGroups(result, state.groups); + + return result; + } + + var groups = state.groups; + var sticky = UNSUPPORTED_Y && re.sticky; + var flags = call(regexpFlags, re); + var source = re.source; + var charsAdded = 0; + var strCopy = str; + + if (sticky) { + flags = replace(flags, 'y', ''); + if (indexOf(flags, 'g') === -1) { + flags += 'g'; + } + + strCopy = stringSlice(str, re.lastIndex); + // Support anchored sticky behavior. + var prevChar = re.lastIndex > 0 && charAt(str, re.lastIndex - 1); + if (re.lastIndex > 0 && + (!re.multiline || re.multiline && prevChar !== '\n' && prevChar !== '\r' && prevChar !== '\u2028' && prevChar !== '\u2029')) { + source = '(?: (?:' + source + '))'; + strCopy = ' ' + strCopy; + charsAdded++; + } + // ^(? + rx + ) is needed, in combination with some str slicing, to + // simulate the 'y' flag. + reCopy = new RegExp('^(?:' + source + ')', flags); + } + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + source + '$(?!\\s)', flags); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; + + var match = call(nativeExec, sticky ? reCopy : re, strCopy); + + if (sticky) { + if (match) { + match.input = str; + match[0] = stringSlice(match[0], charsAdded); + match.index = re.lastIndex; + re.lastIndex += match[0].length; + } else re.lastIndex = 0; + } else if (UPDATES_LAST_INDEX_WRONG && match) { + re.lastIndex = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/ + call(nativeReplace, match[0], reCopy, function () { + for (var i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + if (match && groups) setGroups(match, groups); + + return match; + }; +} + +module.exports = patchedExec; + + +/***/ }), +/* 444 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var defineBuiltInAccessor = __webpack_require__(77); +var regExpFlagsDetection = __webpack_require__(434); +var regExpFlagsGetterImplementation = __webpack_require__(435); + +// `RegExp.prototype.flags` getter +// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags +if (DESCRIPTORS && !regExpFlagsDetection.correct) { + defineBuiltInAccessor(RegExp.prototype, 'flags', { + configurable: true, + get: regExpFlagsGetterImplementation + }); + + regExpFlagsDetection.correct = true; +} + + +/***/ }), +/* 445 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var MISSED_STICKY = __webpack_require__(436).MISSED_STICKY; +var classof = __webpack_require__(15); +var defineBuiltInAccessor = __webpack_require__(77); +var getInternalState = __webpack_require__(51).get; + +var RegExpPrototype = RegExp.prototype; +var $TypeError = TypeError; + +// `RegExp.prototype.sticky` getter +// https://tc39.es/ecma262/#sec-get-regexp.prototype.sticky +if (DESCRIPTORS && MISSED_STICKY) { + defineBuiltInAccessor(RegExpPrototype, 'sticky', { + configurable: true, + get: function sticky() { + if (this === RegExpPrototype) return; + // We can't use InternalStateModule.getterFor because + // we don't add metadata for regexps created by a literal. + if (classof(this) === 'RegExp') { + return !!getInternalState(this).sticky; + } + throw new $TypeError('Incompatible receiver, RegExp required'); + } + }); +} + + +/***/ }), +/* 446 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` since it's moved to entry points +__webpack_require__(442); +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var isCallable = __webpack_require__(21); +var anObject = __webpack_require__(46); +var toString = __webpack_require__(68); + +var DELEGATES_TO_EXEC = function () { + var execCalled = false; + var re = /[ac]/; + re.exec = function () { + execCalled = true; + return /./.exec.apply(this, arguments); + }; + return re.test('abc') === true && execCalled; +}(); + +var nativeTest = /./.test; + +// `RegExp.prototype.test` method +// https://tc39.es/ecma262/#sec-regexp.prototype.test +$({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, { + test: function (S) { + var R = anObject(this); + var string = toString(S); + var exec = R.exec; + if (!isCallable(exec)) return call(nativeTest, R, string); + var result = call(exec, R, string); + if (result === null) return false; + anObject(result); + return true; + } +}); + + +/***/ }), +/* 447 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var PROPER_FUNCTION_NAME = __webpack_require__(49).PROPER; +var defineBuiltIn = __webpack_require__(47); +var anObject = __webpack_require__(46); +var $toString = __webpack_require__(68); +var fails = __webpack_require__(7); +var getRegExpFlags = __webpack_require__(433); + +var TO_STRING = 'toString'; +var RegExpPrototype = RegExp.prototype; +var nativeToString = RegExpPrototype[TO_STRING]; + +var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; }); +// FF44- RegExp#toString has a wrong name +var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING; + +// `RegExp.prototype.toString` method +// https://tc39.es/ecma262/#sec-regexp.prototype.tostring +if (NOT_GENERIC || INCORRECT_NAME) { + defineBuiltIn(RegExpPrototype, TO_STRING, function toString() { + var R = anObject(this); + var pattern = $toString(R.source); + var flags = $toString(getRegExpFlags(R)); + return '/' + pattern + '/' + flags; + }, { unsafe: true }); +} + + +/***/ }), +/* 448 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(449); + + +/***/ }), +/* 449 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var collection = __webpack_require__(291); +var collectionStrong = __webpack_require__(295); + +// `Set` constructor +// https://tc39.es/ecma262/#sec-set-objects +collection('Set', function (init) { + return function Set() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + + +/***/ }), +/* 450 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var difference = __webpack_require__(451); +var fails = __webpack_require__(7); +var setMethodAcceptSetLike = __webpack_require__(459); + +var SET_LIKE_INCORRECT_BEHAVIOR = !setMethodAcceptSetLike('difference', function (result) { + return result.size === 0; +}); + +var FORCED = SET_LIKE_INCORRECT_BEHAVIOR || fails(function () { + // https://bugs.webkit.org/show_bug.cgi?id=288595 + var setLike = { + size: 1, + has: function () { return true; }, + keys: function () { + var index = 0; + return { + next: function () { + var done = index++ > 1; + if (baseSet.has(1)) baseSet.clear(); + return { done: done, value: 2 }; + } + }; + } + }; + // eslint-disable-next-line es/no-set -- testing + var baseSet = new Set([1, 2, 3, 4]); + // eslint-disable-next-line es/no-set-prototype-difference -- testing + return baseSet.difference(setLike).size !== 3; +}); + +// `Set.prototype.difference` method +// https://tc39.es/ecma262/#sec-set.prototype.difference +$({ target: 'Set', proto: true, real: true, forced: FORCED }, { + difference: difference +}); + + +/***/ }), +/* 451 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var SetHelpers = __webpack_require__(453); +var clone = __webpack_require__(454); +var size = __webpack_require__(457); +var getSetRecord = __webpack_require__(458); +var iterateSet = __webpack_require__(455); +var iterateSimple = __webpack_require__(456); + +var has = SetHelpers.has; +var remove = SetHelpers.remove; + +// `Set.prototype.difference` method +// https://tc39.es/ecma262/#sec-set.prototype.difference +module.exports = function difference(other) { + var O = aSet(this); + var otherRec = getSetRecord(other); + var result = clone(O); + if (size(result) <= otherRec.size) iterateSet(result, function (e) { + if (otherRec.includes(e)) remove(result, e); + }); + else iterateSimple(otherRec.getIterator(), function (e) { + if (has(result, e)) remove(result, e); + }); + return result; +}; + + +/***/ }), +/* 452 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var has = __webpack_require__(453).has; + +// Perform ? RequireInternalSlot(M, [[SetData]]) +module.exports = function (it) { + has(it); + return it; +}; + + +/***/ }), +/* 453 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +// eslint-disable-next-line es/no-set -- safe +var SetPrototype = Set.prototype; + +module.exports = { + // eslint-disable-next-line es/no-set -- safe + Set: Set, + add: uncurryThis(SetPrototype.add), + has: uncurryThis(SetPrototype.has), + remove: uncurryThis(SetPrototype['delete']), + proto: SetPrototype +}; + + +/***/ }), +/* 454 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var SetHelpers = __webpack_require__(453); +var iterate = __webpack_require__(455); + +var Set = SetHelpers.Set; +var add = SetHelpers.add; + +module.exports = function (set) { + var result = new Set(); + iterate(set, function (it) { + add(result, it); + }); + return result; +}; + + +/***/ }), +/* 455 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var iterateSimple = __webpack_require__(456); +var SetHelpers = __webpack_require__(453); + +var Set = SetHelpers.Set; +var SetPrototype = SetHelpers.proto; +var forEach = uncurryThis(SetPrototype.forEach); +var keys = uncurryThis(SetPrototype.keys); +var next = keys(new Set()).next; + +module.exports = function (set, fn, interruptible) { + return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn); +}; + + +/***/ }), +/* 456 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); + +module.exports = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) { + var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator; + var next = record.next; + var step, result; + while (!(step = call(next, iterator)).done) { + result = fn(step.value); + if (result !== undefined) return result; + } +}; + + +/***/ }), +/* 457 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThisAccessor = __webpack_require__(119); +var SetHelpers = __webpack_require__(453); + +module.exports = uncurryThisAccessor(SetHelpers.proto, 'size', 'get') || function (set) { + return set.size; +}; + + +/***/ }), +/* 458 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var call = __webpack_require__(8); +var toIntegerOrInfinity = __webpack_require__(61); +var getIteratorDirect = __webpack_require__(267); + +var INVALID_SIZE = 'Invalid size'; +var $RangeError = RangeError; +var $TypeError = TypeError; +var max = Math.max; + +var SetRecord = function (set, intSize) { + this.set = set; + this.size = max(intSize, 0); + this.has = aCallable(set.has); + this.keys = aCallable(set.keys); +}; + +SetRecord.prototype = { + getIterator: function () { + return getIteratorDirect(anObject(call(this.keys, this.set))); + }, + includes: function (it) { + return call(this.has, this.set, it); + } +}; + +// `GetSetRecord` abstract operation +// https://tc39.es/proposal-set-methods/#sec-getsetrecord +module.exports = function (obj) { + anObject(obj); + var numSize = +obj.size; + // NOTE: If size is undefined, then numSize will be NaN + // eslint-disable-next-line no-self-compare -- NaN check + if (numSize !== numSize) throw new $TypeError(INVALID_SIZE); + var intSize = toIntegerOrInfinity(numSize); + if (intSize < 0) throw new $RangeError(INVALID_SIZE); + return new SetRecord(obj, intSize); +}; + + +/***/ }), +/* 459 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); + +var createSetLike = function (size) { + return { + size: size, + has: function () { + return false; + }, + keys: function () { + return { + next: function () { + return { done: true }; + } + }; + } + }; +}; + +var createSetLikeWithInfinitySize = function (size) { + return { + size: size, + has: function () { + return true; + }, + keys: function () { + throw new Error('e'); + } + }; +}; + +module.exports = function (name, callback) { + var Set = getBuiltIn('Set'); + try { + new Set()[name](createSetLike(0)); + try { + // late spec change, early WebKit ~ Safari 17 implementation does not pass it + // https://github.com/tc39/proposal-set-methods/pull/88 + // also covered engines with + // https://bugs.webkit.org/show_bug.cgi?id=272679 + new Set()[name](createSetLike(-1)); + return false; + } catch (error2) { + if (!callback) return true; + // early V8 implementation bug + // https://issues.chromium.org/issues/351332634 + try { + new Set()[name](createSetLikeWithInfinitySize(-Infinity)); + return false; + } catch (error) { + var set = new Set([1, 2]); + return callback(set[name](createSetLikeWithInfinitySize(Infinity))); + } + } + } catch (error) { + return false; + } +}; + + +/***/ }), +/* 460 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var fails = __webpack_require__(7); +var intersection = __webpack_require__(461); +var setMethodAcceptSetLike = __webpack_require__(459); + +var INCORRECT = !setMethodAcceptSetLike('intersection', function (result) { + return result.size === 2 && result.has(1) && result.has(2); +}) || fails(function () { + // eslint-disable-next-line es/no-array-from, es/no-set, es/no-set-prototype-intersection -- testing + return String(Array.from(new Set([1, 2, 3]).intersection(new Set([3, 2])))) !== '3,2'; +}); + +// `Set.prototype.intersection` method +// https://tc39.es/ecma262/#sec-set.prototype.intersection +$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, { + intersection: intersection +}); + + +/***/ }), +/* 461 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var SetHelpers = __webpack_require__(453); +var size = __webpack_require__(457); +var getSetRecord = __webpack_require__(458); +var iterateSet = __webpack_require__(455); +var iterateSimple = __webpack_require__(456); + +var Set = SetHelpers.Set; +var add = SetHelpers.add; +var has = SetHelpers.has; + +// `Set.prototype.intersection` method +// https://tc39.es/ecma262/#sec-set.prototype.intersection +module.exports = function intersection(other) { + var O = aSet(this); + var otherRec = getSetRecord(other); + var result = new Set(); + + if (size(O) > otherRec.size) { + iterateSimple(otherRec.getIterator(), function (e) { + if (has(O, e)) add(result, e); + }); + } else { + iterateSet(O, function (e) { + if (otherRec.includes(e)) add(result, e); + }); + } + + return result; +}; + + +/***/ }), +/* 462 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isDisjointFrom = __webpack_require__(463); +var setMethodAcceptSetLike = __webpack_require__(459); + +var INCORRECT = !setMethodAcceptSetLike('isDisjointFrom', function (result) { + return !result; +}); + +// `Set.prototype.isDisjointFrom` method +// https://tc39.es/ecma262/#sec-set.prototype.isdisjointfrom +$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, { + isDisjointFrom: isDisjointFrom +}); + + +/***/ }), +/* 463 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var has = __webpack_require__(453).has; +var size = __webpack_require__(457); +var getSetRecord = __webpack_require__(458); +var iterateSet = __webpack_require__(455); +var iterateSimple = __webpack_require__(456); +var iteratorClose = __webpack_require__(141); + +// `Set.prototype.isDisjointFrom` method +// https://tc39.es/ecma262/#sec-set.prototype.isdisjointfrom +module.exports = function isDisjointFrom(other) { + var O = aSet(this); + var otherRec = getSetRecord(other); + if (size(O) <= otherRec.size) return iterateSet(O, function (e) { + if (otherRec.includes(e)) return false; + }, true) !== false; + var iterator = otherRec.getIterator(); + return iterateSimple(iterator, function (e) { + if (has(O, e)) return iteratorClose(iterator.iterator, 'normal', false); + }) !== false; +}; + + +/***/ }), +/* 464 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isSubsetOf = __webpack_require__(465); +var setMethodAcceptSetLike = __webpack_require__(459); + +var INCORRECT = !setMethodAcceptSetLike('isSubsetOf', function (result) { + return result; +}); + +// `Set.prototype.isSubsetOf` method +// https://tc39.es/ecma262/#sec-set.prototype.issubsetof +$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, { + isSubsetOf: isSubsetOf +}); + + +/***/ }), +/* 465 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var size = __webpack_require__(457); +var iterate = __webpack_require__(455); +var getSetRecord = __webpack_require__(458); + +// `Set.prototype.isSubsetOf` method +// https://tc39.es/ecma262/#sec-set.prototype.issubsetof +module.exports = function isSubsetOf(other) { + var O = aSet(this); + var otherRec = getSetRecord(other); + if (size(O) > otherRec.size) return false; + return iterate(O, function (e) { + if (!otherRec.includes(e)) return false; + }, true) !== false; +}; + + +/***/ }), +/* 466 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isSupersetOf = __webpack_require__(467); +var setMethodAcceptSetLike = __webpack_require__(459); + +var INCORRECT = !setMethodAcceptSetLike('isSupersetOf', function (result) { + return !result; +}); + +// `Set.prototype.isSupersetOf` method +// https://tc39.es/ecma262/#sec-set.prototype.issupersetof +$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, { + isSupersetOf: isSupersetOf +}); + + +/***/ }), +/* 467 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var has = __webpack_require__(453).has; +var size = __webpack_require__(457); +var getSetRecord = __webpack_require__(458); +var iterateSimple = __webpack_require__(456); +var iteratorClose = __webpack_require__(141); + +// `Set.prototype.isSupersetOf` method +// https://tc39.es/ecma262/#sec-set.prototype.issupersetof +module.exports = function isSupersetOf(other) { + var O = aSet(this); + var otherRec = getSetRecord(other); + if (size(O) < otherRec.size) return false; + var iterator = otherRec.getIterator(); + return iterateSimple(iterator, function (e) { + if (!has(O, e)) return iteratorClose(iterator.iterator, 'normal', false); + }) !== false; +}; + + +/***/ }), +/* 468 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var symmetricDifference = __webpack_require__(469); +var setMethodGetKeysBeforeCloning = __webpack_require__(470); +var setMethodAcceptSetLike = __webpack_require__(459); + +var FORCED = !setMethodAcceptSetLike('symmetricDifference') || !setMethodGetKeysBeforeCloning('symmetricDifference'); + +// `Set.prototype.symmetricDifference` method +// https://tc39.es/ecma262/#sec-set.prototype.symmetricdifference +$({ target: 'Set', proto: true, real: true, forced: FORCED }, { + symmetricDifference: symmetricDifference +}); + + +/***/ }), +/* 469 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var SetHelpers = __webpack_require__(453); +var clone = __webpack_require__(454); +var getSetRecord = __webpack_require__(458); +var iterateSimple = __webpack_require__(456); + +var add = SetHelpers.add; +var has = SetHelpers.has; +var remove = SetHelpers.remove; + +// `Set.prototype.symmetricDifference` method +// https://tc39.es/ecma262/#sec-set.prototype.symmetricdifference +module.exports = function symmetricDifference(other) { + var O = aSet(this); + var keysIter = getSetRecord(other).getIterator(); + var result = clone(O); + iterateSimple(keysIter, function (e) { + if (has(O, e)) remove(result, e); + else add(result, e); + }); + return result; +}; + + +/***/ }), +/* 470 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// Should get iterator record of a set-like object before cloning this +// https://bugs.webkit.org/show_bug.cgi?id=289430 +module.exports = function (METHOD_NAME) { + try { + // eslint-disable-next-line es/no-set -- needed for test + var baseSet = new Set(); + var setLike = { + size: 0, + has: function () { return true; }, + keys: function () { + // eslint-disable-next-line es/no-object-defineproperty -- needed for test + return Object.defineProperty({}, 'next', { + get: function () { + baseSet.clear(); + baseSet.add(4); + return function () { + return { done: true }; + }; + } + }); + } + }; + var result = baseSet[METHOD_NAME](setLike); + + return result.size === 1 && result.values().next().value === 4; + } catch (error) { + return false; + } +}; + + +/***/ }), +/* 471 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var union = __webpack_require__(472); +var setMethodGetKeysBeforeCloning = __webpack_require__(470); +var setMethodAcceptSetLike = __webpack_require__(459); + +var FORCED = !setMethodAcceptSetLike('union') || !setMethodGetKeysBeforeCloning('union'); + +// `Set.prototype.union` method +// https://tc39.es/ecma262/#sec-set.prototype.union +$({ target: 'Set', proto: true, real: true, forced: FORCED }, { + union: union +}); + + +/***/ }), +/* 472 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aSet = __webpack_require__(452); +var add = __webpack_require__(453).add; +var clone = __webpack_require__(454); +var getSetRecord = __webpack_require__(458); +var iterateSimple = __webpack_require__(456); + +// `Set.prototype.union` method +// https://tc39.es/ecma262/#sec-set.prototype.union +module.exports = function union(other) { + var O = aSet(this); + var keysIter = getSetRecord(other).getIterator(); + var result = clone(O); + iterateSimple(keysIter, function (it) { + add(result, it); + }); + return result; +}; + + +/***/ }), +/* 473 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var toIntegerOrInfinity = __webpack_require__(61); +var toString = __webpack_require__(68); +var fails = __webpack_require__(7); + +var charAt = uncurryThis(''.charAt); + +var FORCED = fails(function () { + // eslint-disable-next-line es/no-string-prototype-at -- safe + return '𠮷'.at(-2) !== '\uD842'; +}); + +// `String.prototype.at` method +// https://tc39.es/ecma262/#sec-string.prototype.at +$({ target: 'String', proto: true, forced: FORCED }, { + at: function at(index) { + var S = toString(requireObjectCoercible(this)); + var len = S.length; + var relativeIndex = toIntegerOrInfinity(index); + var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex; + return (k < 0 || k >= len) ? undefined : charAt(S, k); + } +}); + + +/***/ }), +/* 474 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var codeAt = __webpack_require__(475).codeAt; + +// `String.prototype.codePointAt` method +// https://tc39.es/ecma262/#sec-string.prototype.codepointat +$({ target: 'String', proto: true }, { + codePointAt: function codePointAt(pos) { + return codeAt(this, pos); + } +}); + + +/***/ }), +/* 475 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var toIntegerOrInfinity = __webpack_require__(61); +var toString = __webpack_require__(68); +var requireObjectCoercible = __webpack_require__(16); + +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var stringSlice = uncurryThis(''.slice); + +var createMethod = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString(requireObjectCoercible($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +module.exports = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod(true) +}; + + +/***/ }), +/* 476 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(85); +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var notARegExp = __webpack_require__(477); +var requireObjectCoercible = __webpack_require__(16); +var correctIsRegExpLogic = __webpack_require__(478); +var IS_PURE = __webpack_require__(36); + +var slice = uncurryThis(''.slice); +var min = Math.min; + +var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('endsWith'); +// https://github.com/zloirock/core-js/pull/702 +var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'endsWith'); + return descriptor && !descriptor.writable; +}(); + +// `String.prototype.endsWith` method +// https://tc39.es/ecma262/#sec-string.prototype.endswith +$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + endsWith: function endsWith(searchString /* , endPosition = @length */) { + var that = toString(requireObjectCoercible(this)); + notARegExp(searchString); + var search = toString(searchString); + var endPosition = arguments.length > 1 ? arguments[1] : undefined; + var len = that.length; + var end = endPosition === undefined ? len : min(toLength(endPosition), len); + return slice(that, end - search.length, end) === search; + } +}); + + +/***/ }), +/* 477 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isRegExp = __webpack_require__(432); + +var $TypeError = TypeError; + +module.exports = function (it) { + if (isRegExp(it)) { + throw new $TypeError("The method doesn't accept regular expressions"); + } return it; +}; + + +/***/ }), +/* 478 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); + +var MATCH = wellKnownSymbol('match'); + +module.exports = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; +}; + + +/***/ }), +/* 479 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toAbsoluteIndex = __webpack_require__(60); + +var $RangeError = RangeError; +var fromCharCode = String.fromCharCode; +// eslint-disable-next-line es/no-string-fromcodepoint -- required for testing +var $fromCodePoint = String.fromCodePoint; +var join = uncurryThis([].join); + +// length should be 1, old FF problem +var INCORRECT_LENGTH = !!$fromCodePoint && $fromCodePoint.length !== 1; + +// `String.fromCodePoint` method +// https://tc39.es/ecma262/#sec-string.fromcodepoint +$({ target: 'String', stat: true, arity: 1, forced: INCORRECT_LENGTH }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + fromCodePoint: function fromCodePoint(x) { + var elements = []; + var length = arguments.length; + var i = 0; + var code; + while (length > i) { + code = +arguments[i]; + if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw new $RangeError(code + ' is not a valid code point'); + elements[i++] = code < 0x10000 + ? fromCharCode(code) + : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00); + } return join(elements, ''); + } +}); + + +/***/ }), +/* 480 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var notARegExp = __webpack_require__(477); +var requireObjectCoercible = __webpack_require__(16); +var toString = __webpack_require__(68); +var correctIsRegExpLogic = __webpack_require__(478); + +var stringIndexOf = uncurryThis(''.indexOf); + +// `String.prototype.includes` method +// https://tc39.es/ecma262/#sec-string.prototype.includes +$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, { + includes: function includes(searchString /* , position = 0 */) { + return !!~stringIndexOf( + toString(requireObjectCoercible(this)), + toString(notARegExp(searchString)), + arguments.length > 1 ? arguments[1] : undefined + ); + } +}); + + +/***/ }), +/* 481 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var toString = __webpack_require__(68); + +var charCodeAt = uncurryThis(''.charCodeAt); + +// `String.prototype.isWellFormed` method +// https://tc39.es/ecma262/#sec-string.prototype.iswellformed +$({ target: 'String', proto: true }, { + isWellFormed: function isWellFormed() { + var S = toString(requireObjectCoercible(this)); + var length = S.length; + for (var i = 0; i < length; i++) { + var charCode = charCodeAt(S, i); + // single UTF-16 code unit + if ((charCode & 0xF800) !== 0xD800) continue; + // unpaired surrogate + if (charCode >= 0xDC00 || ++i >= length || (charCodeAt(S, i) & 0xFC00) !== 0xDC00) return false; + } return true; + } +}); + + +/***/ }), +/* 482 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var charAt = __webpack_require__(475).charAt; +var toString = __webpack_require__(68); +var InternalStateModule = __webpack_require__(51); +var defineIterator = __webpack_require__(176); +var createIterResultObject = __webpack_require__(179); + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject(point, false); +}); + + +/***/ }), +/* 483 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var fixRegExpWellKnownSymbolLogic = __webpack_require__(484); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var requireObjectCoercible = __webpack_require__(16); +var getMethod = __webpack_require__(29); +var advanceStringIndex = __webpack_require__(485); +var getRegExpFlags = __webpack_require__(433); +var regExpExec = __webpack_require__(486); + +var stringIndexOf = uncurryThis(''.indexOf); + +// @@match logic +fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) { + return [ + // `String.prototype.match` method + // https://tc39.es/ecma262/#sec-string.prototype.match + function match(regexp) { + var O = requireObjectCoercible(this); + var matcher = isObject(regexp) ? getMethod(regexp, MATCH) : undefined; + return matcher ? call(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString(O)); + }, + // `RegExp.prototype[@@match]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@match + function (string) { + var rx = anObject(this); + var S = toString(string); + var res = maybeCallNative(nativeMatch, rx, S); + + if (res.done) return res.value; + + var flags = toString(getRegExpFlags(rx)); + + if (!~stringIndexOf(flags, 'g')) return regExpExec(rx, S); + + var fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v'); + rx.lastIndex = 0; + var A = []; + var n = 0; + var result; + while ((result = regExpExec(rx, S)) !== null) { + var matchStr = toString(result[0]); + A[n] = matchStr; + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + n++; + } + return n === 0 ? null : A; + } + ]; +}); + + +/***/ }), +/* 484 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` since it's moved to entry points +__webpack_require__(442); +var call = __webpack_require__(8); +var defineBuiltIn = __webpack_require__(47); +var regexpExec = __webpack_require__(443); +var fails = __webpack_require__(7); +var wellKnownSymbol = __webpack_require__(33); +var createNonEnumerableProperty = __webpack_require__(43); + +var SPECIES = wellKnownSymbol('species'); +var RegExpPrototype = RegExp.prototype; + +module.exports = function (KEY, exec, FORCED, SHAM) { + var SYMBOL = wellKnownSymbol(KEY); + + var DELEGATES_TO_SYMBOL = !fails(function () { + // String methods call symbol-named RegExp methods + var O = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) !== 7; + }); + + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; + + if (KEY === 'split') { + // We can't use real regex here since it causes deoptimization + // and serious performance degradation in V8 + // https://github.com/zloirock/core-js/issues/306 + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + var constructor = {}; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + constructor[SPECIES] = function () { return re; }; + re = { constructor: constructor, flags: '' }; + // eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation + re[SYMBOL] = /./[SYMBOL]; + } + + re.exec = function () { + execCalled = true; + return null; + }; + + re[SYMBOL](''); + return !execCalled; + }); + + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + FORCED + ) { + var nativeRegExpMethod = /./[SYMBOL]; + var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { + var $exec = regexp.exec; + if ($exec === regexpExec || $exec === RegExpPrototype.exec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: call(nativeRegExpMethod, regexp, str, arg2) }; + } + return { done: true, value: call(nativeMethod, str, regexp, arg2) }; + } + return { done: false }; + }); + + defineBuiltIn(String.prototype, KEY, methods[0]); + defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]); + } + + if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true); +}; + + +/***/ }), +/* 485 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var charAt = __webpack_require__(475).charAt; + +// `AdvanceStringIndex` abstract operation +// https://tc39.es/ecma262/#sec-advancestringindex +module.exports = function (S, index, unicode) { + return index + (unicode ? charAt(S, index).length || 1 : 1); +}; + + +/***/ }), +/* 486 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var isCallable = __webpack_require__(21); +var classof = __webpack_require__(15); +var regexpExec = __webpack_require__(443); + +var $TypeError = TypeError; + +// `RegExpExec` abstract operation +// https://tc39.es/ecma262/#sec-regexpexec +module.exports = function (R, S) { + var exec = R.exec; + if (isCallable(exec)) { + var result = call(exec, R, S); + if (result !== null) anObject(result); + return result; + } + if (classof(R) === 'RegExp') return call(regexpExec, R, S); + throw new $TypeError('RegExp#exec called on incompatible receiver'); +}; + + +/***/ }), +/* 487 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-string-prototype-matchall -- safe */ +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(85); +var createIteratorConstructor = __webpack_require__(177); +var createIterResultObject = __webpack_require__(179); +var requireObjectCoercible = __webpack_require__(16); +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var classof = __webpack_require__(15); +var isRegExp = __webpack_require__(432); +var getRegExpFlags = __webpack_require__(433); +var getMethod = __webpack_require__(29); +var defineBuiltIn = __webpack_require__(47); +var fails = __webpack_require__(7); +var wellKnownSymbol = __webpack_require__(33); +var speciesConstructor = __webpack_require__(380); +var advanceStringIndex = __webpack_require__(485); +var regExpExec = __webpack_require__(486); +var InternalStateModule = __webpack_require__(51); +var IS_PURE = __webpack_require__(36); + +var MATCH_ALL = wellKnownSymbol('matchAll'); +var REGEXP_STRING = 'RegExp String'; +var REGEXP_STRING_ITERATOR = REGEXP_STRING + ' Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(REGEXP_STRING_ITERATOR); +var RegExpPrototype = RegExp.prototype; +var $TypeError = TypeError; +var stringIndexOf = uncurryThis(''.indexOf); +var nativeMatchAll = uncurryThis(''.matchAll); + +var WORKS_WITH_NON_GLOBAL_REGEX = !!nativeMatchAll && !fails(function () { + nativeMatchAll('a', /./); +}); + +var $RegExpStringIterator = createIteratorConstructor(function RegExpStringIterator(regexp, string, $global, fullUnicode) { + setInternalState(this, { + type: REGEXP_STRING_ITERATOR, + regexp: regexp, + string: string, + global: $global, + unicode: fullUnicode, + done: false + }); +}, REGEXP_STRING, function next() { + var state = getInternalState(this); + if (state.done) return createIterResultObject(undefined, true); + var R = state.regexp; + var S = state.string; + var match = regExpExec(R, S); + if (match === null) { + state.done = true; + return createIterResultObject(undefined, true); + } + if (state.global) { + if (toString(match[0]) === '') R.lastIndex = advanceStringIndex(S, toLength(R.lastIndex), state.unicode); + return createIterResultObject(match, false); + } + state.done = true; + return createIterResultObject(match, false); +}); + +var $matchAll = function (string) { + var R = anObject(this); + var S = toString(string); + var C = speciesConstructor(R, RegExp); + var flags = toString(getRegExpFlags(R)); + var matcher, $global, fullUnicode; + matcher = new C(C === RegExp ? R.source : R, flags); + $global = !!~stringIndexOf(flags, 'g'); + fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v'); + matcher.lastIndex = toLength(R.lastIndex); + return new $RegExpStringIterator(matcher, S, $global, fullUnicode); +}; + +// `String.prototype.matchAll` method +// https://tc39.es/ecma262/#sec-string.prototype.matchall +$({ target: 'String', proto: true, forced: WORKS_WITH_NON_GLOBAL_REGEX }, { + matchAll: function matchAll(regexp) { + var O = requireObjectCoercible(this); + var flags, S, matcher, rx; + if (isObject(regexp)) { + if (isRegExp(regexp)) { + flags = toString(requireObjectCoercible(getRegExpFlags(regexp))); + if (!~stringIndexOf(flags, 'g')) throw new $TypeError('`.matchAll` does not allow non-global regexes'); + } + if (WORKS_WITH_NON_GLOBAL_REGEX) return nativeMatchAll(O, regexp); + matcher = getMethod(regexp, MATCH_ALL); + if (matcher === undefined && IS_PURE && classof(regexp) === 'RegExp') matcher = $matchAll; + if (matcher) return call(matcher, regexp, O); + } else if (WORKS_WITH_NON_GLOBAL_REGEX) return nativeMatchAll(O, regexp); + S = toString(O); + rx = new RegExp(regexp, 'g'); + return IS_PURE ? call($matchAll, rx, S) : rx[MATCH_ALL](S); + } +}); + +IS_PURE || MATCH_ALL in RegExpPrototype || defineBuiltIn(RegExpPrototype, MATCH_ALL, $matchAll); + + +/***/ }), +/* 488 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $padEnd = __webpack_require__(247).end; +var WEBKIT_BUG = __webpack_require__(489); + +// `String.prototype.padEnd` method +// https://tc39.es/ecma262/#sec-string.prototype.padend +$({ target: 'String', proto: true, forced: WEBKIT_BUG }, { + padEnd: function padEnd(maxLength /* , fillString = ' ' */) { + return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 489 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/zloirock/core-js/issues/280 +var userAgent = __webpack_require__(28); + +module.exports = /Version\/10(?:\.\d+){1,2}(?: [\w./]+)?(?: Mobile\/\w+)? Safari\//.test(userAgent); + + +/***/ }), +/* 490 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $padStart = __webpack_require__(247).start; +var WEBKIT_BUG = __webpack_require__(489); + +// `String.prototype.padStart` method +// https://tc39.es/ecma262/#sec-string.prototype.padstart +$({ target: 'String', proto: true, forced: WEBKIT_BUG }, { + padStart: function padStart(maxLength /* , fillString = ' ' */) { + return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } +}); + + +/***/ }), +/* 491 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toIndexedObject = __webpack_require__(12); +var toObject = __webpack_require__(39); +var toString = __webpack_require__(68); +var lengthOfArrayLike = __webpack_require__(63); + +var push = uncurryThis([].push); +var join = uncurryThis([].join); + +// `String.raw` method +// https://tc39.es/ecma262/#sec-string.raw +$({ target: 'String', stat: true }, { + raw: function raw(template) { + var rawTemplate = toIndexedObject(toObject(template).raw); + var literalSegments = lengthOfArrayLike(rawTemplate); + if (!literalSegments) return ''; + var argumentsLength = arguments.length; + var elements = []; + var i = 0; + while (true) { + push(elements, toString(rawTemplate[i++])); + if (i === literalSegments) return join(elements, ''); + if (i < argumentsLength) push(elements, toString(arguments[i])); + } + } +}); + + +/***/ }), +/* 492 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var repeat = __webpack_require__(248); + +// `String.prototype.repeat` method +// https://tc39.es/ecma262/#sec-string.prototype.repeat +$({ target: 'String', proto: true }, { + repeat: repeat +}); + + +/***/ }), +/* 493 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var apply = __webpack_require__(95); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var fixRegExpWellKnownSymbolLogic = __webpack_require__(484); +var fails = __webpack_require__(7); +var anObject = __webpack_require__(46); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var toIntegerOrInfinity = __webpack_require__(61); +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var requireObjectCoercible = __webpack_require__(16); +var advanceStringIndex = __webpack_require__(485); +var getMethod = __webpack_require__(29); +var getSubstitution = __webpack_require__(494); +var getRegExpFlags = __webpack_require__(433); +var regExpExec = __webpack_require__(486); +var wellKnownSymbol = __webpack_require__(33); + +var REPLACE = wellKnownSymbol('replace'); +var max = Math.max; +var min = Math.min; +var concat = uncurryThis([].concat); +var push = uncurryThis([].push); +var stringIndexOf = uncurryThis(''.indexOf); +var stringSlice = uncurryThis(''.slice); + +var maybeToString = function (it) { + return it === undefined ? it : String(it); +}; + +// IE <= 11 replaces $0 with the whole match, as if it was $& +// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 +var REPLACE_KEEPS_$0 = (function () { + // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing + return 'a'.replace(/./, '$0') === '$0'; +})(); + +// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string +var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { + if (/./[REPLACE]) { + return /./[REPLACE]('a', '$0') === ''; + } + return false; +})(); + +var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive + return ''.replace(re, '$') !== '7'; +}); + +// @@replace logic +fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) { + var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0'; + + return [ + // `String.prototype.replace` method + // https://tc39.es/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = requireObjectCoercible(this); + var replacer = isObject(searchValue) ? getMethod(searchValue, REPLACE) : undefined; + return replacer + ? call(replacer, searchValue, O, replaceValue) + : call(nativeReplace, toString(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace + function (string, replaceValue) { + var rx = anObject(this); + var S = toString(string); + + var functionalReplace = isCallable(replaceValue); + if (!functionalReplace) replaceValue = toString(replaceValue); + var flags = toString(getRegExpFlags(rx)); + + if ( + typeof replaceValue == 'string' && + !~stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) && + !~stringIndexOf(replaceValue, '$<') && + !~stringIndexOf(flags, 'y') + ) { + var res = maybeCallNative(nativeReplace, rx, S, replaceValue); + if (res.done) return res.value; + } + + var global = !!~stringIndexOf(flags, 'g'); + var fullUnicode; + if (global) { + fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v'); + rx.lastIndex = 0; + } + + var results = []; + var result; + while (true) { + result = regExpExec(rx, S); + if (result === null) break; + + push(results, result); + if (!global) break; + + var matchStr = toString(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + } + + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; + + var matched = toString(result[0]); + var position = max(min(toIntegerOrInfinity(result.index), S.length), 0); + var captures = []; + var replacement; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = concat([matched], captures, position, S); + if (namedCaptures !== undefined) push(replacerArgs, namedCaptures); + replacement = toString(apply(replaceValue, undefined, replacerArgs)); + } else { + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); + } + if (position >= nextSourcePosition) { + accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; + } + } + + return accumulatedResult + stringSlice(S, nextSourcePosition); + } + ]; +}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE); + + +/***/ }), +/* 494 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var toObject = __webpack_require__(39); + +var floor = Math.floor; +var charAt = uncurryThis(''.charAt); +var replace = uncurryThis(''.replace); +var stringSlice = uncurryThis(''.slice); +// eslint-disable-next-line redos/no-vulnerable -- safe +var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g; +var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g; + +// `GetSubstitution` abstract operation +// https://tc39.es/ecma262/#sec-getsubstitution +module.exports = function (matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return replace(replacement, symbols, function (match, ch) { + var capture; + switch (charAt(ch, 0)) { + case '$': return '$'; + case '&': return matched; + case '`': return stringSlice(str, 0, position); + case "'": return stringSlice(str, tailPos); + case '<': + capture = namedCaptures[stringSlice(ch, 1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); +}; + + +/***/ }), +/* 495 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var isCallable = __webpack_require__(21); +var isObject = __webpack_require__(20); +var isRegExp = __webpack_require__(432); +var toString = __webpack_require__(68); +var getMethod = __webpack_require__(29); +var getRegExpFlags = __webpack_require__(433); +var getSubstitution = __webpack_require__(494); +var wellKnownSymbol = __webpack_require__(33); +var IS_PURE = __webpack_require__(36); + +var REPLACE = wellKnownSymbol('replace'); +var $TypeError = TypeError; +var indexOf = uncurryThis(''.indexOf); +var replace = uncurryThis(''.replace); +var stringSlice = uncurryThis(''.slice); +var max = Math.max; + +// `String.prototype.replaceAll` method +// https://tc39.es/ecma262/#sec-string.prototype.replaceall +$({ target: 'String', proto: true }, { + replaceAll: function replaceAll(searchValue, replaceValue) { + var O = requireObjectCoercible(this); + var IS_REG_EXP, flags, replacer, string, searchString, functionalReplace, searchLength, advanceBy, position, replacement; + var endOfLastMatch = 0; + var result = ''; + if (isObject(searchValue)) { + IS_REG_EXP = isRegExp(searchValue); + if (IS_REG_EXP) { + flags = toString(requireObjectCoercible(getRegExpFlags(searchValue))); + if (!~indexOf(flags, 'g')) throw new $TypeError('`.replaceAll` does not allow non-global regexes'); + } + replacer = getMethod(searchValue, REPLACE); + if (replacer) return call(replacer, searchValue, O, replaceValue); + if (IS_PURE && IS_REG_EXP) return replace(toString(O), searchValue, replaceValue); + } + string = toString(O); + searchString = toString(searchValue); + functionalReplace = isCallable(replaceValue); + if (!functionalReplace) replaceValue = toString(replaceValue); + searchLength = searchString.length; + advanceBy = max(1, searchLength); + position = indexOf(string, searchString); + while (position !== -1) { + replacement = functionalReplace + ? toString(replaceValue(searchString, position, string)) + : getSubstitution(searchString, string, position, [], undefined, replaceValue); + result += stringSlice(string, endOfLastMatch, position) + replacement; + endOfLastMatch = position + searchLength; + position = position + advanceBy > string.length ? -1 : indexOf(string, searchString, position + advanceBy); + } + if (endOfLastMatch < string.length) { + result += stringSlice(string, endOfLastMatch); + } + return result; + } +}); + + +/***/ }), +/* 496 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var fixRegExpWellKnownSymbolLogic = __webpack_require__(484); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var requireObjectCoercible = __webpack_require__(16); +var sameValue = __webpack_require__(362); +var toString = __webpack_require__(68); +var getMethod = __webpack_require__(29); +var regExpExec = __webpack_require__(486); + +// @@search logic +fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) { + return [ + // `String.prototype.search` method + // https://tc39.es/ecma262/#sec-string.prototype.search + function search(regexp) { + var O = requireObjectCoercible(this); + var searcher = isObject(regexp) ? getMethod(regexp, SEARCH) : undefined; + return searcher ? call(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString(O)); + }, + // `RegExp.prototype[@@search]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@search + function (string) { + var rx = anObject(this); + var S = toString(string); + var res = maybeCallNative(nativeSearch, rx, S); + + if (res.done) return res.value; + + var previousLastIndex = rx.lastIndex; + if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0; + var result = regExpExec(rx, S); + if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex; + return result === null ? -1 : result.index; + } + ]; +}); + + +/***/ }), +/* 497 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var fixRegExpWellKnownSymbolLogic = __webpack_require__(484); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var requireObjectCoercible = __webpack_require__(16); +var speciesConstructor = __webpack_require__(380); +var advanceStringIndex = __webpack_require__(485); +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var getMethod = __webpack_require__(29); +var getRegExpFlags = __webpack_require__(433); +var regExpExec = __webpack_require__(486); +var stickyHelpers = __webpack_require__(436); +var fails = __webpack_require__(7); + +var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y; +var MAX_UINT32 = 0xFFFFFFFF; +var min = Math.min; +var push = uncurryThis([].push); +var stringSlice = uncurryThis(''.slice); +var stringIndexOf = uncurryThis(''.indexOf); + +// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec +// Weex JS has frozen built-in prototypes, so use try / catch wrapper +var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { + // eslint-disable-next-line regexp/no-empty-group -- required for testing + var re = /(?:)/; + var originalExec = re.exec; + re.exec = function () { return originalExec.apply(this, arguments); }; + var result = 'ab'.split(re); + return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b'; +}); + +var BUGGY = 'abbc'.split(/(b)*/)[1] === 'c' || + // eslint-disable-next-line regexp/no-empty-group -- required for testing + 'test'.split(/(?:)/, -1).length !== 4 || + 'ab'.split(/(?:ab)*/).length !== 2 || + '.'.split(/(.?)(.?)/).length !== 4 || + // eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing + '.'.split(/()()/).length > 1 || + ''.split(/.?/).length; + +// @@split logic +fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) { + var internalSplit = '0'.split(undefined, 0).length ? function (separator, limit) { + return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit); + } : nativeSplit; + + return [ + // `String.prototype.split` method + // https://tc39.es/ecma262/#sec-string.prototype.split + function split(separator, limit) { + var O = requireObjectCoercible(this); + var splitter = isObject(separator) ? getMethod(separator, SPLIT) : undefined; + return splitter + ? call(splitter, separator, O, limit) + : call(internalSplit, toString(O), separator, limit); + }, + // `RegExp.prototype[@@split]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@split + // + // NOTE: This cannot be properly polyfilled in engines that don't support + // the 'y' flag. + function (string, limit) { + var rx = anObject(this); + var S = toString(string); + + if (!BUGGY) { + var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit); + if (res.done) return res.value; + } + + var C = speciesConstructor(rx, RegExp); + var flags = toString(getRegExpFlags(rx)); + var unicodeMatching = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v'); + if (UNSUPPORTED_Y) { + if (!~stringIndexOf(flags, 'g')) flags += 'g'; + } else if (!~stringIndexOf(flags, 'y')) flags += 'y'; + // ^(? + rx + ) is needed, in combination with some S slicing, to + // simulate the 'y' flag. + var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags); + var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; + if (lim === 0) return []; + if (S.length === 0) return regExpExec(splitter, S) === null ? [S] : []; + var p = 0; + var q = 0; + var A = []; + while (q < S.length) { + splitter.lastIndex = UNSUPPORTED_Y ? 0 : q; + var z = regExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S); + var e; + if ( + z === null || + (e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p + ) { + q = advanceStringIndex(S, q, unicodeMatching); + } else { + push(A, stringSlice(S, p, q)); + if (A.length === lim) return A; + for (var i = 1; i <= z.length - 1; i++) { + push(A, z[i]); + if (A.length === lim) return A; + } + q = p = e; + } + } + push(A, stringSlice(S, p)); + return A; + } + ]; +}, BUGGY || !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y); + + +/***/ }), +/* 498 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(85); +var getOwnPropertyDescriptor = __webpack_require__(5).f; +var toLength = __webpack_require__(64); +var toString = __webpack_require__(68); +var notARegExp = __webpack_require__(477); +var requireObjectCoercible = __webpack_require__(16); +var correctIsRegExpLogic = __webpack_require__(478); +var IS_PURE = __webpack_require__(36); + +var stringSlice = uncurryThis(''.slice); +var min = Math.min; + +var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith'); +// https://github.com/zloirock/core-js/pull/702 +var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; +}(); + +// `String.prototype.startsWith` method +// https://tc39.es/ecma262/#sec-string.prototype.startswith +$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = toString(requireObjectCoercible(this)); + notARegExp(searchString); + var search = toString(searchString); + var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + return stringSlice(that, index, index + search.length) === search; + } +}); + + +/***/ }), +/* 499 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var toIntegerOrInfinity = __webpack_require__(61); +var toString = __webpack_require__(68); + +var stringSlice = uncurryThis(''.slice); +var max = Math.max; +var min = Math.min; + +// eslint-disable-next-line unicorn/prefer-string-slice -- required for testing +var FORCED = !''.substr || 'ab'.substr(-1) !== 'b'; + +// `String.prototype.substr` method +// https://tc39.es/ecma262/#sec-string.prototype.substr +$({ target: 'String', proto: true, forced: FORCED }, { + substr: function substr(start, length) { + var that = toString(requireObjectCoercible(this)); + var size = that.length; + var intStart = toIntegerOrInfinity(start); + var finalStart = intStart < 0 ? max(size + intStart, 0) : min(intStart, size); + var intLength = length === undefined ? size : toIntegerOrInfinity(length); + if (intLength <= 0) return ''; + var intEnd = min(finalStart + intLength, size); + return finalStart >= intEnd ? '' : stringSlice(that, finalStart, intEnd); + } +}); + + +/***/ }), +/* 500 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var toString = __webpack_require__(68); +var fails = __webpack_require__(7); + +var $Array = Array; +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var join = uncurryThis([].join); +// eslint-disable-next-line es/no-string-prototype-towellformed -- safe +var $toWellFormed = ''.toWellFormed; +var REPLACEMENT_CHARACTER = '\uFFFD'; + +// Safari bug +var TO_STRING_CONVERSION_BUG = $toWellFormed && fails(function () { + return call($toWellFormed, 1) !== '1'; +}); + +// `String.prototype.toWellFormed` method +// https://tc39.es/ecma262/#sec-string.prototype.towellformed +$({ target: 'String', proto: true, forced: TO_STRING_CONVERSION_BUG }, { + toWellFormed: function toWellFormed() { + var S = toString(requireObjectCoercible(this)); + if (TO_STRING_CONVERSION_BUG) return call($toWellFormed, S); + var length = S.length; + var result = $Array(length); + for (var i = 0; i < length; i++) { + var charCode = charCodeAt(S, i); + // single UTF-16 code unit + if ((charCode & 0xF800) !== 0xD800) result[i] = charAt(S, i); + // unpaired surrogate + else if (charCode >= 0xDC00 || i + 1 >= length || (charCodeAt(S, i + 1) & 0xFC00) !== 0xDC00) result[i] = REPLACEMENT_CHARACTER; + // surrogate pair + else { + result[i] = charAt(S, i); + result[++i] = charAt(S, i); + } + } return join(result, ''); + } +}); + + +/***/ }), +/* 501 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $trim = __webpack_require__(325).trim; +var forcedStringTrimMethod = __webpack_require__(502); + +// `String.prototype.trim` method +// https://tc39.es/ecma262/#sec-string.prototype.trim +$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { + trim: function trim() { + return $trim(this); + } +}); + + +/***/ }), +/* 502 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var PROPER_FUNCTION_NAME = __webpack_require__(49).PROPER; +var fails = __webpack_require__(7); +var whitespaces = __webpack_require__(326); + +var non = '\u200B\u0085\u180E'; + +// check that a method works with the correct list +// of whitespaces and has a correct name +module.exports = function (METHOD_NAME) { + return fails(function () { + return !!whitespaces[METHOD_NAME]() + || non[METHOD_NAME]() !== non + || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME); + }); +}; + + +/***/ }), +/* 503 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this line from `core-js@4` +__webpack_require__(504); +var $ = __webpack_require__(3); +var trimEnd = __webpack_require__(505); + +// `String.prototype.trimEnd` method +// https://tc39.es/ecma262/#sec-string.prototype.trimend +// eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe +$({ target: 'String', proto: true, name: 'trimEnd', forced: ''.trimEnd !== trimEnd }, { + trimEnd: trimEnd +}); + + +/***/ }), +/* 504 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var trimEnd = __webpack_require__(505); + +// `String.prototype.trimRight` method +// https://tc39.es/ecma262/#sec-string.prototype.trimend +// eslint-disable-next-line es/no-string-prototype-trimleft-trimright -- safe +$({ target: 'String', proto: true, name: 'trimEnd', forced: ''.trimRight !== trimEnd }, { + trimRight: trimEnd +}); + + +/***/ }), +/* 505 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $trimEnd = __webpack_require__(325).end; +var forcedStringTrimMethod = __webpack_require__(502); + +// `String.prototype.{ trimEnd, trimRight }` method +// https://tc39.es/ecma262/#sec-string.prototype.trimend +// https://tc39.es/ecma262/#String.prototype.trimright +module.exports = forcedStringTrimMethod('trimEnd') ? function trimEnd() { + return $trimEnd(this); +// eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe +} : ''.trimEnd; + + +/***/ }), +/* 506 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this line from `core-js@4` +__webpack_require__(507); +var $ = __webpack_require__(3); +var trimStart = __webpack_require__(508); + +// `String.prototype.trimStart` method +// https://tc39.es/ecma262/#sec-string.prototype.trimstart +// eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe +$({ target: 'String', proto: true, name: 'trimStart', forced: ''.trimStart !== trimStart }, { + trimStart: trimStart +}); + + +/***/ }), +/* 507 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var trimStart = __webpack_require__(508); + +// `String.prototype.trimLeft` method +// https://tc39.es/ecma262/#sec-string.prototype.trimleft +// eslint-disable-next-line es/no-string-prototype-trimleft-trimright -- safe +$({ target: 'String', proto: true, name: 'trimStart', forced: ''.trimLeft !== trimStart }, { + trimLeft: trimStart +}); + + +/***/ }), +/* 508 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $trimStart = __webpack_require__(325).start; +var forcedStringTrimMethod = __webpack_require__(502); + +// `String.prototype.{ trimStart, trimLeft }` method +// https://tc39.es/ecma262/#sec-string.prototype.trimstart +// https://tc39.es/ecma262/#String.prototype.trimleft +module.exports = forcedStringTrimMethod('trimStart') ? function trimStart() { + return $trimStart(this); +// eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe +} : ''.trimStart; + + +/***/ }), +/* 509 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.anchor` method +// https://tc39.es/ecma262/#sec-string.prototype.anchor +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('anchor') }, { + anchor: function anchor(name) { + return createHTML(this, 'a', 'name', name); + } +}); + + +/***/ }), +/* 510 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var requireObjectCoercible = __webpack_require__(16); +var toString = __webpack_require__(68); + +var quot = /"/g; +var replace = uncurryThis(''.replace); + +// `CreateHTML` abstract operation +// https://tc39.es/ecma262/#sec-createhtml +module.exports = function (string, tag, attribute, value) { + var S = toString(requireObjectCoercible(string)); + var p1 = '<' + tag; + if (attribute !== '') p1 += ' ' + attribute + '="' + replace(toString(value), quot, '"') + '"'; + return p1 + '>' + S + ''; +}; + + +/***/ }), +/* 511 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); + +// check the existence of a method, lowercase +// of a tag and escaping quotes in arguments +module.exports = function (METHOD_NAME) { + return fails(function () { + var test = ''[METHOD_NAME]('"'); + return test !== test.toLowerCase() || test.split('"').length > 3; + }); +}; + + +/***/ }), +/* 512 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.big` method +// https://tc39.es/ecma262/#sec-string.prototype.big +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('big') }, { + big: function big() { + return createHTML(this, 'big', '', ''); + } +}); + + +/***/ }), +/* 513 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.blink` method +// https://tc39.es/ecma262/#sec-string.prototype.blink +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('blink') }, { + blink: function blink() { + return createHTML(this, 'blink', '', ''); + } +}); + + +/***/ }), +/* 514 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.bold` method +// https://tc39.es/ecma262/#sec-string.prototype.bold +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('bold') }, { + bold: function bold() { + return createHTML(this, 'b', '', ''); + } +}); + + +/***/ }), +/* 515 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.fixed` method +// https://tc39.es/ecma262/#sec-string.prototype.fixed +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fixed') }, { + fixed: function fixed() { + return createHTML(this, 'tt', '', ''); + } +}); + + +/***/ }), +/* 516 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.fontcolor` method +// https://tc39.es/ecma262/#sec-string.prototype.fontcolor +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontcolor') }, { + fontcolor: function fontcolor(color) { + return createHTML(this, 'font', 'color', color); + } +}); + + +/***/ }), +/* 517 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.fontsize` method +// https://tc39.es/ecma262/#sec-string.prototype.fontsize +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontsize') }, { + fontsize: function fontsize(size) { + return createHTML(this, 'font', 'size', size); + } +}); + + +/***/ }), +/* 518 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.italics` method +// https://tc39.es/ecma262/#sec-string.prototype.italics +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('italics') }, { + italics: function italics() { + return createHTML(this, 'i', '', ''); + } +}); + + +/***/ }), +/* 519 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.link` method +// https://tc39.es/ecma262/#sec-string.prototype.link +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, { + link: function link(url) { + return createHTML(this, 'a', 'href', url); + } +}); + + +/***/ }), +/* 520 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.small` method +// https://tc39.es/ecma262/#sec-string.prototype.small +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('small') }, { + small: function small() { + return createHTML(this, 'small', '', ''); + } +}); + + +/***/ }), +/* 521 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.strike` method +// https://tc39.es/ecma262/#sec-string.prototype.strike +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('strike') }, { + strike: function strike() { + return createHTML(this, 'strike', '', ''); + } +}); + + +/***/ }), +/* 522 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.sub` method +// https://tc39.es/ecma262/#sec-string.prototype.sub +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sub') }, { + sub: function sub() { + return createHTML(this, 'sub', '', ''); + } +}); + + +/***/ }), +/* 523 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createHTML = __webpack_require__(510); +var forcedStringHTMLMethod = __webpack_require__(511); + +// `String.prototype.sup` method +// https://tc39.es/ecma262/#sec-string.prototype.sup +$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sup') }, { + sup: function sup() { + return createHTML(this, 'sup', '', ''); + } +}); + + +/***/ }), +/* 524 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Float32Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Float32', function (init) { + return function Float32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 525 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var call = __webpack_require__(8); +var DESCRIPTORS = __webpack_require__(6); +var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(526); +var ArrayBufferViewCore = __webpack_require__(223); +var ArrayBufferModule = __webpack_require__(212); +var anInstance = __webpack_require__(215); +var createPropertyDescriptor = __webpack_require__(11); +var createNonEnumerableProperty = __webpack_require__(43); +var isIntegralNumber = __webpack_require__(331); +var toIndex = __webpack_require__(216); +var toOffset = __webpack_require__(527); +var toUint8Clamped = __webpack_require__(528); +var toPropertyKey = __webpack_require__(18); +var hasOwn = __webpack_require__(38); +var classof = __webpack_require__(69); +var isObject = __webpack_require__(20); +var isSymbol = __webpack_require__(22); +var create = __webpack_require__(71); +var isPrototypeOf = __webpack_require__(24); +var setPrototypeOf = __webpack_require__(118); +var getOwnPropertyNames = __webpack_require__(57).f; +var typedArrayFrom = __webpack_require__(529); +var forEach = __webpack_require__(83).forEach; +var setSpecies = __webpack_require__(200); +var defineBuiltInAccessor = __webpack_require__(77); +var definePropertyModule = __webpack_require__(44); +var getOwnPropertyDescriptorModule = __webpack_require__(5); +var arrayFromConstructorAndList = __webpack_require__(204); +var InternalStateModule = __webpack_require__(51); +var inheritIfRequired = __webpack_require__(123); + +var getInternalState = InternalStateModule.get; +var setInternalState = InternalStateModule.set; +var enforceInternalState = InternalStateModule.enforce; +var nativeDefineProperty = definePropertyModule.f; +var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; +var RangeError = globalThis.RangeError; +var ArrayBuffer = ArrayBufferModule.ArrayBuffer; +var ArrayBufferPrototype = ArrayBuffer.prototype; +var DataView = ArrayBufferModule.DataView; +var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS; +var TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG; +var TypedArray = ArrayBufferViewCore.TypedArray; +var TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype; +var isTypedArray = ArrayBufferViewCore.isTypedArray; +var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT'; +var WRONG_LENGTH = 'Wrong length'; + +var addGetter = function (it, key) { + defineBuiltInAccessor(it, key, { + configurable: true, + get: function () { + return getInternalState(this)[key]; + } + }); +}; + +var isArrayBuffer = function (it) { + var klass; + return isPrototypeOf(ArrayBufferPrototype, it) || (klass = classof(it)) === 'ArrayBuffer' || klass === 'SharedArrayBuffer'; +}; + +var isTypedArrayIndex = function (target, key) { + return isTypedArray(target) + && !isSymbol(key) + && key in target + && isIntegralNumber(+key) + && key >= 0; +}; + +var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) { + key = toPropertyKey(key); + return isTypedArrayIndex(target, key) + ? createPropertyDescriptor(2, target[key]) + : nativeGetOwnPropertyDescriptor(target, key); +}; + +var wrappedDefineProperty = function defineProperty(target, key, descriptor) { + key = toPropertyKey(key); + if (isTypedArrayIndex(target, key) + && isObject(descriptor) + && hasOwn(descriptor, 'value') + && !hasOwn(descriptor, 'get') + && !hasOwn(descriptor, 'set') + // TODO: add validation descriptor w/o calling accessors + && !descriptor.configurable + && (!hasOwn(descriptor, 'writable') || descriptor.writable) + && (!hasOwn(descriptor, 'enumerable') || descriptor.enumerable) + ) { + target[key] = descriptor.value; + return target; + } return nativeDefineProperty(target, key, descriptor); +}; + +if (DESCRIPTORS) { + if (!NATIVE_ARRAY_BUFFER_VIEWS) { + getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor; + definePropertyModule.f = wrappedDefineProperty; + addGetter(TypedArrayPrototype, 'buffer'); + addGetter(TypedArrayPrototype, 'byteOffset'); + addGetter(TypedArrayPrototype, 'byteLength'); + addGetter(TypedArrayPrototype, 'length'); + } + + $({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, { + getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor, + defineProperty: wrappedDefineProperty + }); + + module.exports = function (TYPE, wrapper, CLAMPED) { + var BYTES = TYPE.match(/\d+/)[0] / 8; + var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array'; + var GETTER = 'get' + TYPE; + var SETTER = 'set' + TYPE; + var NativeTypedArrayConstructor = globalThis[CONSTRUCTOR_NAME]; + var TypedArrayConstructor = NativeTypedArrayConstructor; + var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype; + var exported = {}; + + var getter = function (that, index) { + var data = getInternalState(that); + return data.view[GETTER](index * BYTES + data.byteOffset, true); + }; + + var setter = function (that, index, value) { + var data = getInternalState(that); + data.view[SETTER](index * BYTES + data.byteOffset, CLAMPED ? toUint8Clamped(value) : value, true); + }; + + var addElement = function (that, index) { + nativeDefineProperty(that, index, { + get: function () { + return getter(this, index); + }, + set: function (value) { + return setter(this, index, value); + }, + enumerable: true + }); + }; + + if (!NATIVE_ARRAY_BUFFER_VIEWS) { + TypedArrayConstructor = wrapper(function (that, data, offset, $length) { + anInstance(that, TypedArrayConstructorPrototype); + var index = 0; + var byteOffset = 0; + var buffer, byteLength, length; + if (!isObject(data)) { + length = toIndex(data); + byteLength = length * BYTES; + buffer = new ArrayBuffer(byteLength); + } else if (isArrayBuffer(data)) { + buffer = data; + byteOffset = toOffset(offset, BYTES); + var $len = data.byteLength; + if ($length === undefined) { + if ($len % BYTES) throw new RangeError(WRONG_LENGTH); + byteLength = $len - byteOffset; + if (byteLength < 0) throw new RangeError(WRONG_LENGTH); + } else { + byteLength = toIndex($length) * BYTES; + if (byteLength + byteOffset > $len) throw new RangeError(WRONG_LENGTH); + } + length = byteLength / BYTES; + } else if (isTypedArray(data)) { + return arrayFromConstructorAndList(TypedArrayConstructor, data); + } else { + return call(typedArrayFrom, TypedArrayConstructor, data); + } + setInternalState(that, { + buffer: buffer, + byteOffset: byteOffset, + byteLength: byteLength, + length: length, + view: new DataView(buffer) + }); + while (index < length) addElement(that, index++); + }); + + if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray); + TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype); + } else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) { + TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) { + anInstance(dummy, TypedArrayConstructorPrototype); + return inheritIfRequired(function () { + if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data)); + if (isArrayBuffer(data)) return $length !== undefined + ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length) + : typedArrayOffset !== undefined + ? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES)) + : new NativeTypedArrayConstructor(data); + if (isTypedArray(data)) return arrayFromConstructorAndList(TypedArrayConstructor, data); + return call(typedArrayFrom, TypedArrayConstructor, data); + }(), dummy, TypedArrayConstructor); + }); + + if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray); + forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) { + if (!(key in TypedArrayConstructor)) { + createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]); + } + }); + TypedArrayConstructor.prototype = TypedArrayConstructorPrototype; + } + + if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) { + createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor); + } + + enforceInternalState(TypedArrayConstructorPrototype).TypedArrayConstructor = TypedArrayConstructor; + + if (TYPED_ARRAY_TAG) { + createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME); + } + + var FORCED = TypedArrayConstructor !== NativeTypedArrayConstructor; + + exported[CONSTRUCTOR_NAME] = TypedArrayConstructor; + + $({ global: true, constructor: true, forced: FORCED, sham: !NATIVE_ARRAY_BUFFER_VIEWS }, exported); + + if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) { + createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES); + } + + if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) { + createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES); + } + + setSpecies(CONSTRUCTOR_NAME); + }; +} else module.exports = function () { /* empty */ }; + + +/***/ }), +/* 526 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable no-new, sonarjs/inconsistent-function-call -- required for testing */ +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); +var checkCorrectnessOfIteration = __webpack_require__(171); +var NATIVE_ARRAY_BUFFER_VIEWS = __webpack_require__(223).NATIVE_ARRAY_BUFFER_VIEWS; + +var ArrayBuffer = globalThis.ArrayBuffer; +var Int8Array = globalThis.Int8Array; + +module.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () { + Int8Array(1); +}) || !fails(function () { + new Int8Array(-1); +}) || !checkCorrectnessOfIteration(function (iterable) { + new Int8Array(); + new Int8Array(null); + new Int8Array(1.5); + new Int8Array(iterable); +}, true) || fails(function () { + // Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill + return new Int8Array(new ArrayBuffer(2), 1, undefined).length !== 1; +}); + + +/***/ }), +/* 527 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toPositiveInteger = __webpack_require__(269); + +var $RangeError = RangeError; + +module.exports = function (it, BYTES) { + var offset = toPositiveInteger(it); + if (offset % BYTES) throw new $RangeError('Wrong offset'); + return offset; +}; + + +/***/ }), +/* 528 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var floor = Math.floor; + +// https://tc39.es/ecma262/#sec-touint8clamp +module.exports = function (it) { + var number = +it; + // eslint-disable-next-line no-self-compare -- NaN check + if (number !== number || number <= 0) return 0; + if (number >= 0xFF) return 0xFF; + var f = floor(number); + if (f + 0.5 < number) return f + 1; + if (number < f + 0.5) return f; + // round-half-to-even (banker's rounding) + return f % 2 === 0 ? f : f + 1; +}; + + +/***/ }), +/* 529 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var aConstructor = __webpack_require__(381); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var getIterator = __webpack_require__(139); +var getIteratorMethod = __webpack_require__(140); +var isArrayIteratorMethod = __webpack_require__(137); +var isBigIntArray = __webpack_require__(530); +var aTypedArrayConstructor = __webpack_require__(223).aTypedArrayConstructor; +var toBigInt = __webpack_require__(531); + +module.exports = function from(source /* , mapfn, thisArg */) { + var C = aConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) aCallable(mapfn); + var O = toObject(source); + var iteratorMethod = getIteratorMethod(O); + var i, length, result, thisIsBigIntArray, value, step, iterator, next; + if (iteratorMethod && !isArrayIteratorMethod(iteratorMethod)) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + O = []; + while (!(step = call(next, iterator)).done) { + O.push(step.value); + } + } + if (mapping && argumentsLength > 2) { + mapfn = bind(mapfn, arguments[2]); + } + length = lengthOfArrayLike(O); + result = new (aTypedArrayConstructor(C))(length); + thisIsBigIntArray = isBigIntArray(result); + for (i = 0; length > i; i++) { + value = mapping ? mapfn(O[i], i) : O[i]; + // FF30- typed arrays doesn't properly convert objects to typed array values + result[i] = thisIsBigIntArray ? toBigInt(value) : +value; + } + return result; +}; + + +/***/ }), +/* 530 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(69); + +module.exports = function (it) { + var klass = classof(it); + return klass === 'BigInt64Array' || klass === 'BigUint64Array'; +}; + + +/***/ }), +/* 531 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var toPrimitive = __webpack_require__(19); + +var $TypeError = TypeError; + +// `ToBigInt` abstract operation +// https://tc39.es/ecma262/#sec-tobigint +module.exports = function (argument) { + var prim = toPrimitive(argument, 'number'); + if (typeof prim == 'number') throw new $TypeError("Can't convert number to bigint"); + // eslint-disable-next-line es/no-bigint -- safe + return BigInt(prim); +}; + + +/***/ }), +/* 532 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Float64Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Float64', function (init) { + return function Float64Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 533 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Int8Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Int8', function (init) { + return function Int8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 534 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Int16Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Int16', function (init) { + return function Int16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 535 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Int32Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Int32', function (init) { + return function Int32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 536 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Uint8Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint8', function (init) { + return function Uint8Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 537 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Uint8ClampedArray` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint8', function (init) { + return function Uint8ClampedArray(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}, true); + + +/***/ }), +/* 538 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Uint16Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint16', function (init) { + return function Uint16Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 539 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var createTypedArrayConstructor = __webpack_require__(525); + +// `Uint32Array` constructor +// https://tc39.es/ecma262/#sec-typedarray-objects +createTypedArrayConstructor('Uint32', function (init) { + return function Uint32Array(data, byteOffset, length) { + return init(this, data, byteOffset, length); + }; +}); + + +/***/ }), +/* 540 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var lengthOfArrayLike = __webpack_require__(63); +var toIntegerOrInfinity = __webpack_require__(61); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.at` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.at +exportTypedArrayMethod('at', function at(index) { + var O = aTypedArray(this); + var len = lengthOfArrayLike(O); + var relativeIndex = toIntegerOrInfinity(index); + var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex; + return (k < 0 || k >= len) ? undefined : O[k]; +}); + + +/***/ }), +/* 541 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var ArrayBufferViewCore = __webpack_require__(223); +var $ArrayCopyWithin = __webpack_require__(151); + +var u$ArrayCopyWithin = uncurryThis($ArrayCopyWithin); +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.copyWithin` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin +exportTypedArrayMethod('copyWithin', function copyWithin(target, start /* , end */) { + return u$ArrayCopyWithin(aTypedArray(this), target, start, arguments.length > 2 ? arguments[2] : undefined); +}); + + +/***/ }), +/* 542 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $every = __webpack_require__(83).every; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.every` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.every +exportTypedArrayMethod('every', function every(callbackfn /* , thisArg */) { + return $every(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 543 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $fill = __webpack_require__(156); +var toBigInt = __webpack_require__(531); +var classof = __webpack_require__(69); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var slice = uncurryThis(''.slice); + +// V8 ~ Chrome < 59, Safari < 14.1, FF < 55, Edge <=18 +var CONVERSION_BUG = fails(function () { + var count = 0; + // eslint-disable-next-line es/no-typed-arrays -- safe + new Int8Array(2).fill({ valueOf: function () { return count++; } }); + return count !== 1; +}); + +// `%TypedArray%.prototype.fill` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill +exportTypedArrayMethod('fill', function fill(value /* , start, end */) { + var length = arguments.length; + aTypedArray(this); + var actualValue = slice(classof(this), 0, 3) === 'Big' ? toBigInt(value) : +value; + return call($fill, this, actualValue, length > 1 ? arguments[1] : undefined, length > 2 ? arguments[2] : undefined); +}, CONVERSION_BUG); + + +/***/ }), +/* 544 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $filter = __webpack_require__(83).filter; +var fromSameTypeAndList = __webpack_require__(545); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.filter` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter +exportTypedArrayMethod('filter', function filter(callbackfn /* , thisArg */) { + var list = $filter(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return fromSameTypeAndList(this, list); +}); + + +/***/ }), +/* 545 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var arrayFromConstructorAndList = __webpack_require__(204); +var getTypedArrayConstructor = __webpack_require__(223).getTypedArrayConstructor; + +module.exports = function (instance, list) { + return arrayFromConstructorAndList(getTypedArrayConstructor(instance), list); +}; + + +/***/ }), +/* 546 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $find = __webpack_require__(83).find; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.find` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.find +exportTypedArrayMethod('find', function find(predicate /* , thisArg */) { + return $find(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 547 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $findIndex = __webpack_require__(83).findIndex; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.findIndex` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex +exportTypedArrayMethod('findIndex', function findIndex(predicate /* , thisArg */) { + return $findIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 548 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $findLast = __webpack_require__(161).findLast; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.findLast` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.findlast +exportTypedArrayMethod('findLast', function findLast(predicate /* , thisArg */) { + return $findLast(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 549 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $findLastIndex = __webpack_require__(161).findLastIndex; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.findLastIndex` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.findlastindex +exportTypedArrayMethod('findLastIndex', function findLastIndex(predicate /* , thisArg */) { + return $findLastIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 550 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $forEach = __webpack_require__(83).forEach; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.forEach` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach +exportTypedArrayMethod('forEach', function forEach(callbackfn /* , thisArg */) { + $forEach(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 551 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(526); +var exportTypedArrayStaticMethod = __webpack_require__(223).exportTypedArrayStaticMethod; +var typedArrayFrom = __webpack_require__(529); + +// `%TypedArray%.from` method +// https://tc39.es/ecma262/#sec-%typedarray%.from +exportTypedArrayStaticMethod('from', typedArrayFrom, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS); + + +/***/ }), +/* 552 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $includes = __webpack_require__(59).includes; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.includes` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes +exportTypedArrayMethod('includes', function includes(searchElement /* , fromIndex */) { + return $includes(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 553 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $indexOf = __webpack_require__(59).indexOf; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.indexOf` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof +exportTypedArrayMethod('indexOf', function indexOf(searchElement /* , fromIndex */) { + return $indexOf(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 554 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var fails = __webpack_require__(7); +var uncurryThis = __webpack_require__(14); +var ArrayBufferViewCore = __webpack_require__(223); +var ArrayIterators = __webpack_require__(175); +var wellKnownSymbol = __webpack_require__(33); + +var ITERATOR = wellKnownSymbol('iterator'); +var Uint8Array = globalThis.Uint8Array; +var arrayValues = uncurryThis(ArrayIterators.values); +var arrayKeys = uncurryThis(ArrayIterators.keys); +var arrayEntries = uncurryThis(ArrayIterators.entries); +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var TypedArrayPrototype = Uint8Array && Uint8Array.prototype; + +var GENERIC = !fails(function () { + TypedArrayPrototype[ITERATOR].call([1]); +}); + +var ITERATOR_IS_VALUES = !!TypedArrayPrototype + && TypedArrayPrototype.values + && TypedArrayPrototype[ITERATOR] === TypedArrayPrototype.values + && TypedArrayPrototype.values.name === 'values'; + +var typedArrayValues = function values() { + return arrayValues(aTypedArray(this)); +}; + +// `%TypedArray%.prototype.entries` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries +exportTypedArrayMethod('entries', function entries() { + return arrayEntries(aTypedArray(this)); +}, GENERIC); +// `%TypedArray%.prototype.keys` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys +exportTypedArrayMethod('keys', function keys() { + return arrayKeys(aTypedArray(this)); +}, GENERIC); +// `%TypedArray%.prototype.values` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.values +exportTypedArrayMethod('values', typedArrayValues, GENERIC || !ITERATOR_IS_VALUES, { name: 'values' }); +// `%TypedArray%.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype-@@iterator +exportTypedArrayMethod(ITERATOR, typedArrayValues, GENERIC || !ITERATOR_IS_VALUES, { name: 'values' }); + + +/***/ }), +/* 555 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var uncurryThis = __webpack_require__(14); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $join = uncurryThis([].join); + +// `%TypedArray%.prototype.join` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.join +exportTypedArrayMethod('join', function join(separator) { + return $join(aTypedArray(this), separator); +}); + + +/***/ }), +/* 556 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var apply = __webpack_require__(95); +var $lastIndexOf = __webpack_require__(182); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.lastIndexOf` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof +exportTypedArrayMethod('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) { + var length = arguments.length; + return apply($lastIndexOf, aTypedArray(this), length > 1 ? [searchElement, arguments[1]] : [searchElement]); +}); + + +/***/ }), +/* 557 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $map = __webpack_require__(83).map; +var fromSameTypeAndList = __webpack_require__(545); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.map` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.map +exportTypedArrayMethod('map', function map(mapfn /* , thisArg */) { + var list = $map(aTypedArray(this), mapfn, arguments.length > 1 ? arguments[1] : undefined); + return fromSameTypeAndList(this, list); +}); + + +/***/ }), +/* 558 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(526); + +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var exportTypedArrayStaticMethod = ArrayBufferViewCore.exportTypedArrayStaticMethod; + +// `%TypedArray%.of` method +// https://tc39.es/ecma262/#sec-%typedarray%.of +exportTypedArrayStaticMethod('of', function of(/* ...items */) { + var index = 0; + var length = arguments.length; + var result = new (aTypedArrayConstructor(this))(length); + while (length > index) result[index] = arguments[index++]; + return result; +}, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS); + + +/***/ }), +/* 559 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $reduce = __webpack_require__(187).left; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.reduce` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce +exportTypedArrayMethod('reduce', function reduce(callbackfn /* , initialValue */) { + var length = arguments.length; + return $reduce(aTypedArray(this), callbackfn, length, length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 560 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $reduceRight = __webpack_require__(187).right; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.reduceRight` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright +exportTypedArrayMethod('reduceRight', function reduceRight(callbackfn /* , initialValue */) { + var length = arguments.length; + return $reduceRight(aTypedArray(this), callbackfn, length, length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 561 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var floor = Math.floor; + +// `%TypedArray%.prototype.reverse` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reverse +exportTypedArrayMethod('reverse', function reverse() { + var that = this; + var length = aTypedArray(that).length; + var middle = floor(length / 2); + var index = 0; + var value; + while (index < middle) { + value = that[index]; + that[index++] = that[--length]; + that[length] = value; + } return that; +}); + + +/***/ }), +/* 562 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var call = __webpack_require__(8); +var ArrayBufferViewCore = __webpack_require__(223); +var lengthOfArrayLike = __webpack_require__(63); +var toOffset = __webpack_require__(527); +var toIndexedObject = __webpack_require__(39); +var fails = __webpack_require__(7); + +var RangeError = globalThis.RangeError; +var Int8Array = globalThis.Int8Array; +var Int8ArrayPrototype = Int8Array && Int8Array.prototype; +var $set = Int8ArrayPrototype && Int8ArrayPrototype.set; +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +var WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS = !fails(function () { + // eslint-disable-next-line es/no-typed-arrays -- required for testing + var array = new Uint8ClampedArray(2); + call($set, array, { length: 1, 0: 3 }, 1); + return array[1] !== 3; +}); + +// https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other +var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS && fails(function () { + var array = new Int8Array(2); + array.set(1); + array.set('2', 1); + return array[0] !== 0 || array[1] !== 2; +}); + +// `%TypedArray%.prototype.set` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set +exportTypedArrayMethod('set', function set(arrayLike /* , offset */) { + aTypedArray(this); + var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1); + var src = toIndexedObject(arrayLike); + if (WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS) return call($set, this, src, offset); + var length = this.length; + var len = lengthOfArrayLike(src); + var index = 0; + if (len + offset > length) throw new RangeError('Wrong length'); + while (index < len) this[offset + index] = src[index++]; +}, !WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG); + + +/***/ }), +/* 563 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var fails = __webpack_require__(7); +var arraySlice = __webpack_require__(76); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +var FORCED = fails(function () { + // eslint-disable-next-line es/no-typed-arrays -- required for testing + new Int8Array(1).slice(); +}); + +// `%TypedArray%.prototype.slice` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice +exportTypedArrayMethod('slice', function slice(start, end) { + var list = arraySlice(aTypedArray(this), start, end); + var C = getTypedArrayConstructor(this); + var index = 0; + var length = list.length; + var result = new C(length); + while (length > index) result[index] = list[index++]; + return result; +}, FORCED); + + +/***/ }), +/* 564 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $some = __webpack_require__(83).some; + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.some` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.some +exportTypedArrayMethod('some', function some(callbackfn /* , thisArg */) { + return $some(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); +}); + + +/***/ }), +/* 565 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(85); +var fails = __webpack_require__(7); +var aCallable = __webpack_require__(30); +var internalSort = __webpack_require__(195); +var ArrayBufferViewCore = __webpack_require__(223); +var FF = __webpack_require__(196); +var IE_OR_EDGE = __webpack_require__(197); +var V8 = __webpack_require__(27); +var WEBKIT = __webpack_require__(198); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var Uint16Array = globalThis.Uint16Array; +var nativeSort = Uint16Array && uncurryThis(Uint16Array.prototype.sort); + +// WebKit +var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort && !(fails(function () { + nativeSort(new Uint16Array(2), null); +}) && fails(function () { + nativeSort(new Uint16Array(2), {}); +})); + +var STABLE_SORT = !!nativeSort && !fails(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 74; + if (FF) return FF < 67; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 602; + + var array = new Uint16Array(516); + var expected = Array(516); + var index, mod; + + for (index = 0; index < 516; index++) { + mod = index % 4; + array[index] = 515 - index; + expected[index] = index - 2 * mod + 3; + } + + nativeSort(array, function (a, b) { + return (a / 4 | 0) - (b / 4 | 0); + }); + + for (index = 0; index < 516; index++) { + if (array[index] !== expected[index]) return true; + } +}); + +var getSortCompare = function (comparefn) { + return function (x, y) { + if (comparefn !== undefined) return +comparefn(x, y) || 0; + // eslint-disable-next-line no-self-compare -- NaN check + if (y !== y) return x !== x ? 0 : -1; + // eslint-disable-next-line no-self-compare -- NaN check + if (x !== x) return 1; + if (x === 0 && y === 0) return 1 / x > 0 ? (1 / y > 0 ? 0 : 1) : (1 / y > 0 ? -1 : 0); + return x > y ? 1 : x < y ? -1 : 0; + }; +}; + +// `%TypedArray%.prototype.sort` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort +exportTypedArrayMethod('sort', function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + if (STABLE_SORT) return nativeSort(this, comparefn); + + return internalSort(aTypedArray(this), getSortCompare(comparefn)); +}, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS); + + +/***/ }), +/* 566 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var toLength = __webpack_require__(64); +var toAbsoluteIndex = __webpack_require__(60); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.subarray` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray +exportTypedArrayMethod('subarray', function subarray(begin, end) { + var O = aTypedArray(this); + var length = O.length; + var beginIndex = toAbsoluteIndex(begin, length); + var C = getTypedArrayConstructor(O); + return new C( + O.buffer, + O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT, + toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex) + ); +}); + + +/***/ }), +/* 567 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var apply = __webpack_require__(95); +var ArrayBufferViewCore = __webpack_require__(223); +var fails = __webpack_require__(7); +var arraySlice = __webpack_require__(76); + +var Int8Array = globalThis.Int8Array; +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var $toLocaleString = [].toLocaleString; + +// iOS Safari 6.x fails here +var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () { + $toLocaleString.call(new Int8Array(1)); +}); + +var FORCED = fails(function () { + return [1, 2].toLocaleString() !== new Int8Array([1, 2]).toLocaleString(); +}) || !fails(function () { + Int8Array.prototype.toLocaleString.call([1, 2]); +}); + +// `%TypedArray%.prototype.toLocaleString` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring +exportTypedArrayMethod('toLocaleString', function toLocaleString() { + return apply( + $toLocaleString, + TO_LOCALE_STRING_BUG ? arraySlice(aTypedArray(this)) : aTypedArray(this), + arraySlice(arguments) + ); +}, FORCED); + + +/***/ }), +/* 568 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var lengthOfArrayLike = __webpack_require__(63); +var ArrayBufferViewCore = __webpack_require__(223); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; + +// `%TypedArray%.prototype.toReversed` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.toreversed +exportTypedArrayMethod('toReversed', function toReversed() { + var O = aTypedArray(this); + var len = lengthOfArrayLike(O); + var A = new (getTypedArrayConstructor(O))(len); + var k = 0; + for (; k < len; k++) A[k] = O[len - k - 1]; + return A; +}); + + +/***/ }), +/* 569 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); +var arrayFromConstructorAndList = __webpack_require__(204); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var sort = uncurryThis(ArrayBufferViewCore.TypedArrayPrototype.sort); + +// `%TypedArray%.prototype.toSorted` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tosorted +exportTypedArrayMethod('toSorted', function toSorted(compareFn) { + if (compareFn !== undefined) aCallable(compareFn); + var O = aTypedArray(this); + var A = arrayFromConstructorAndList(getTypedArrayConstructor(O), O); + return sort(A, compareFn); +}); + + +/***/ }), +/* 570 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var exportTypedArrayMethod = __webpack_require__(223).exportTypedArrayMethod; +var fails = __webpack_require__(7); +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); + +var Uint8Array = globalThis.Uint8Array; +var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {}; +var arrayToString = [].toString; +var join = uncurryThis([].join); + +if (fails(function () { arrayToString.call({}); })) { + arrayToString = function toString() { + return join(this); + }; +} + +var IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString !== arrayToString; + +// `%TypedArray%.prototype.toString` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tostring +exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD); + + +/***/ }), +/* 571 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var isBigIntArray = __webpack_require__(530); +var lengthOfArrayLike = __webpack_require__(63); +var toIntegerOrInfinity = __webpack_require__(61); +var toBigInt = __webpack_require__(531); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +var $RangeError = RangeError; + +var PROPER_ORDER = function () { + try { + // eslint-disable-next-line no-throw-literal, es/no-typed-arrays, es/no-array-prototype-with -- required for testing + new Int8Array(1)['with'](2, { valueOf: function () { throw 8; } }); + } catch (error) { + // some early implementations, like WebKit, does not follow the final semantic + // https://github.com/tc39/proposal-change-array-by-copy/pull/86 + return error === 8; + } +}(); + +// Bug in WebKit. It should truncate a negative fractional index to zero, but instead throws an error +var THROW_ON_NEGATIVE_FRACTIONAL_INDEX = PROPER_ORDER && function () { + try { + // eslint-disable-next-line es/no-typed-arrays, es/no-array-prototype-with -- required for testing + new Int8Array(1)['with'](-0.5, 1); + } catch (error) { + return true; + } +}(); + +// `%TypedArray%.prototype.with` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.with +exportTypedArrayMethod('with', { 'with': function (index, value) { + var O = aTypedArray(this); + var len = lengthOfArrayLike(O); + var relativeIndex = toIntegerOrInfinity(index); + var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex; + var numericValue = isBigIntArray(O) ? toBigInt(value) : +value; + if (actualIndex >= len || actualIndex < 0) throw new $RangeError('Incorrect index'); + var A = new (getTypedArrayConstructor(O))(len); + var k = 0; + for (; k < len; k++) A[k] = k === actualIndex ? numericValue : O[k]; + return A; +} }['with'], !PROPER_ORDER || THROW_ON_NEGATIVE_FRACTIONAL_INDEX); + + +/***/ }), +/* 572 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var arrayFromConstructorAndList = __webpack_require__(204); +var $fromBase64 = __webpack_require__(573); + +var Uint8Array = globalThis.Uint8Array; + +var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.fromBase64 || !function () { + // Webkit not throw an error on odd length string + try { + Uint8Array.fromBase64('a'); + return; + } catch (error) { /* empty */ } + try { + Uint8Array.fromBase64('', null); + } catch (error) { + return true; + } +}(); + +// `Uint8Array.fromBase64` method +// https://tc39.es/ecma262/#sec-uint8array.frombase64 +if (Uint8Array) $({ target: 'Uint8Array', stat: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, { + fromBase64: function fromBase64(string /* , options */) { + var result = $fromBase64(string, arguments.length > 1 ? arguments[1] : undefined, null, 0x1FFFFFFFFFFFFF); + return arrayFromConstructorAndList(Uint8Array, result.bytes); + } +}); + + +/***/ }), +/* 573 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var anObjectOrUndefined = __webpack_require__(574); +var aString = __webpack_require__(440); +var hasOwn = __webpack_require__(38); +var base64Map = __webpack_require__(575); +var getAlphabetOption = __webpack_require__(576); +var notDetached = __webpack_require__(236); + +var base64Alphabet = base64Map.c2i; +var base64UrlAlphabet = base64Map.c2iUrl; + +var SyntaxError = globalThis.SyntaxError; +var TypeError = globalThis.TypeError; +var at = uncurryThis(''.charAt); + +var skipAsciiWhitespace = function (string, index) { + var length = string.length; + for (;index < length; index++) { + var chr = at(string, index); + if (chr !== ' ' && chr !== '\t' && chr !== '\n' && chr !== '\f' && chr !== '\r') break; + } return index; +}; + +var decodeBase64Chunk = function (chunk, alphabet, throwOnExtraBits) { + var chunkLength = chunk.length; + + if (chunkLength < 4) { + chunk += chunkLength === 2 ? 'AA' : 'A'; + } + + var triplet = (alphabet[at(chunk, 0)] << 18) + + (alphabet[at(chunk, 1)] << 12) + + (alphabet[at(chunk, 2)] << 6) + + alphabet[at(chunk, 3)]; + + var chunkBytes = [ + (triplet >> 16) & 255, + (triplet >> 8) & 255, + triplet & 255 + ]; + + if (chunkLength === 2) { + if (throwOnExtraBits && chunkBytes[1] !== 0) { + throw new SyntaxError('Extra bits'); + } + return [chunkBytes[0]]; + } + + if (chunkLength === 3) { + if (throwOnExtraBits && chunkBytes[2] !== 0) { + throw new SyntaxError('Extra bits'); + } + return [chunkBytes[0], chunkBytes[1]]; + } + + return chunkBytes; +}; + +var writeBytes = function (bytes, elements, written) { + var elementsLength = elements.length; + for (var index = 0; index < elementsLength; index++) { + bytes[written + index] = elements[index]; + } + return written + elementsLength; +}; + +/* eslint-disable max-statements, max-depth -- TODO */ +module.exports = function (string, options, into, maxLength) { + aString(string); + anObjectOrUndefined(options); + var alphabet = getAlphabetOption(options) === 'base64' ? base64Alphabet : base64UrlAlphabet; + var lastChunkHandling = options ? options.lastChunkHandling : undefined; + + if (lastChunkHandling === undefined) lastChunkHandling = 'loose'; + + if (lastChunkHandling !== 'loose' && lastChunkHandling !== 'strict' && lastChunkHandling !== 'stop-before-partial') { + throw new TypeError('Incorrect `lastChunkHandling` option'); + } + + if (into) notDetached(into.buffer); + + var stringLength = string.length; + var bytes = into || []; + var written = 0; + var read = 0; + var chunk = ''; + var index = 0; + + if (maxLength) while (true) { + index = skipAsciiWhitespace(string, index); + if (index === stringLength) { + if (chunk.length > 0) { + if (lastChunkHandling === 'stop-before-partial') { + break; + } + if (lastChunkHandling === 'loose') { + if (chunk.length === 1) { + throw new SyntaxError('Malformed padding: exactly one additional character'); + } + written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written); + } else { + throw new SyntaxError('Missing padding'); + } + } + read = stringLength; + break; + } + var chr = at(string, index); + ++index; + if (chr === '=') { + if (chunk.length < 2) { + throw new SyntaxError('Padding is too early'); + } + index = skipAsciiWhitespace(string, index); + if (chunk.length === 2) { + if (index === stringLength) { + if (lastChunkHandling === 'stop-before-partial') { + break; + } + throw new SyntaxError('Malformed padding: only one ='); + } + if (at(string, index) === '=') { + ++index; + index = skipAsciiWhitespace(string, index); + } + } + if (index < stringLength) { + throw new SyntaxError('Unexpected character after padding'); + } + written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, lastChunkHandling === 'strict'), written); + read = stringLength; + break; + } + if (!hasOwn(alphabet, chr)) { + throw new SyntaxError('Unexpected character'); + } + var remainingBytes = maxLength - written; + if (remainingBytes === 1 && chunk.length === 2 || remainingBytes === 2 && chunk.length === 3) { + // special case: we can fit exactly the number of bytes currently represented by chunk, so we were just checking for `=` + break; + } + + chunk += chr; + if (chunk.length === 4) { + written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written); + chunk = ''; + read = index; + if (written === maxLength) { + break; + } + } + } + + return { bytes: bytes, read: read, written: written }; +}; + + +/***/ }), +/* 574 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(20); + +var $String = String; +var $TypeError = TypeError; + +module.exports = function (argument) { + if (argument === undefined || isObject(argument)) return argument; + throw new $TypeError($String(argument) + ' is not an object or undefined'); +}; + + +/***/ }), +/* 575 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var commonAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'; +var base64Alphabet = commonAlphabet + '+/'; +var base64UrlAlphabet = commonAlphabet + '-_'; + +var inverse = function (characters) { + // TODO: use `Object.create(null)` in `core-js@4` + var result = {}; + var index = 0; + for (; index < 64; index++) result[characters.charAt(index)] = index; + return result; +}; + +module.exports = { + i2c: base64Alphabet, + c2i: inverse(base64Alphabet), + i2cUrl: base64UrlAlphabet, + c2iUrl: inverse(base64UrlAlphabet) +}; + + +/***/ }), +/* 576 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $TypeError = TypeError; + +module.exports = function (options) { + var alphabet = options && options.alphabet; + if (alphabet === undefined || alphabet === 'base64' || alphabet === 'base64url') return alphabet || 'base64'; + throw new $TypeError('Incorrect `alphabet` option'); +}; + + +/***/ }), +/* 577 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var aString = __webpack_require__(440); +var $fromHex = __webpack_require__(578); + +// `Uint8Array.fromHex` method +// https://tc39.es/ecma262/#sec-uint8array.fromhex +if (globalThis.Uint8Array) $({ target: 'Uint8Array', stat: true }, { + fromHex: function fromHex(string) { + return $fromHex(aString(string)).bytes; + } +}); + + +/***/ }), +/* 578 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); + +var Uint8Array = globalThis.Uint8Array; +var SyntaxError = globalThis.SyntaxError; +var min = Math.min; +var stringMatch = uncurryThis(''.match); + +module.exports = function (string, into) { + var stringLength = string.length; + if (stringLength % 2 !== 0) throw new SyntaxError('String should be an even number of characters'); + var maxLength = into ? min(into.length, stringLength / 2) : stringLength / 2; + var bytes = into || new Uint8Array(maxLength); + var segments = stringMatch(string, /.{2}/g); + var written = 0; + for (; written < maxLength; written++) { + var result = +('0x' + segments[written] + '0'); + // eslint-disable-next-line no-self-compare -- NaN check + if (result !== result) { + throw new SyntaxError('String should only contain hex characters'); + } + bytes[written] = result >> 4; + } + return { bytes: bytes, read: written << 1 }; +}; + + +/***/ }), +/* 579 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var $fromBase64 = __webpack_require__(573); +var anUint8Array = __webpack_require__(580); + +var Uint8Array = globalThis.Uint8Array; + +var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.prototype.setFromBase64 || !function () { + var target = new Uint8Array([255, 255, 255, 255, 255]); + try { + target.setFromBase64('', null); + return; + } catch (error) { /* empty */ } + // Webkit not throw an error on odd length string + try { + target.setFromBase64('a'); + return; + } catch (error) { /* empty */ } + try { + target.setFromBase64('MjYyZg==='); + } catch (error) { + return target[0] === 50 && target[1] === 54 && target[2] === 50 && target[3] === 255 && target[4] === 255; + } +}(); + +// `Uint8Array.prototype.setFromBase64` method +// https://tc39.es/ecma262/#sec-uint8array.prototype.setfrombase64 +if (Uint8Array) $({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, { + setFromBase64: function setFromBase64(string /* , options */) { + anUint8Array(this); + + var result = $fromBase64(string, arguments.length > 1 ? arguments[1] : undefined, this, this.length); + + return { read: result.read, written: result.written }; + } +}); + + +/***/ }), +/* 580 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(69); + +var $TypeError = TypeError; + +// Perform ? RequireInternalSlot(argument, [[TypedArrayName]]) +// If argument.[[TypedArrayName]] is not "Uint8Array", throw a TypeError exception +module.exports = function (argument) { + if (classof(argument) === 'Uint8Array') return argument; + throw new $TypeError('Argument is not an Uint8Array'); +}; + + +/***/ }), +/* 581 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var aString = __webpack_require__(440); +var anUint8Array = __webpack_require__(580); +var notDetached = __webpack_require__(236); +var $fromHex = __webpack_require__(578); + +// Should not throw an error on length-tracking views over ResizableArrayBuffer +// https://issues.chromium.org/issues/454630441 +function throwsOnLengthTrackingView() { + try { + // eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- required for testing + var rab = new ArrayBuffer(16, { maxByteLength: 1024 }); + // eslint-disable-next-line es/no-uint8array-prototype-setfromhex, es/no-typed-arrays -- required for testing + new Uint8Array(rab).setFromHex('cafed00d'); + } catch (error) { + return true; + } +} + +// `Uint8Array.prototype.setFromHex` method +// https://tc39.es/ecma262/#sec-uint8array.prototype.setfromhex +if (globalThis.Uint8Array) $({ target: 'Uint8Array', proto: true, forced: throwsOnLengthTrackingView() }, { + setFromHex: function setFromHex(string) { + anUint8Array(this); + aString(string); + notDetached(this.buffer); + var read = $fromHex(string, this).read; + return { read: read, written: read / 2 }; + } +}); + + +/***/ }), +/* 582 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var anObjectOrUndefined = __webpack_require__(574); +var anUint8Array = __webpack_require__(580); +var notDetached = __webpack_require__(236); +var base64Map = __webpack_require__(575); +var getAlphabetOption = __webpack_require__(576); + +var base64Alphabet = base64Map.i2c; +var base64UrlAlphabet = base64Map.i2cUrl; + +var charAt = uncurryThis(''.charAt); + +var Uint8Array = globalThis.Uint8Array; + +var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.prototype.toBase64 || !function () { + try { + var target = new Uint8Array(); + target.toBase64(null); + } catch (error) { + return true; + } +}(); + +// `Uint8Array.prototype.toBase64` method +// https://tc39.es/ecma262/#sec-uint8array.prototype.tobase64 +if (Uint8Array) $({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, { + toBase64: function toBase64(/* options */) { + var array = anUint8Array(this); + var options = arguments.length ? anObjectOrUndefined(arguments[0]) : undefined; + var alphabet = getAlphabetOption(options) === 'base64' ? base64Alphabet : base64UrlAlphabet; + var omitPadding = !!options && !!options.omitPadding; + notDetached(this.buffer); + + var result = ''; + var i = 0; + var length = array.length; + var triplet; + + var at = function (shift) { + return charAt(alphabet, (triplet >> (6 * shift)) & 63); + }; + + for (; i + 2 < length; i += 3) { + triplet = (array[i] << 16) + (array[i + 1] << 8) + array[i + 2]; + result += at(3) + at(2) + at(1) + at(0); + } + if (i + 2 === length) { + triplet = (array[i] << 16) + (array[i + 1] << 8); + result += at(3) + at(2) + at(1) + (omitPadding ? '' : '='); + } else if (i + 1 === length) { + triplet = array[i] << 16; + result += at(3) + at(2) + (omitPadding ? '' : '=='); + } + + return result; + } +}); + + +/***/ }), +/* 583 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var anUint8Array = __webpack_require__(580); +var notDetached = __webpack_require__(236); + +var numberToString = uncurryThis(1.1.toString); +var join = uncurryThis([].join); +var $Array = Array; + +var Uint8Array = globalThis.Uint8Array; + +var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array || !Uint8Array.prototype.toHex || !(function () { + try { + var target = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]); + return target.toHex() === 'ffffffffffffffff'; + } catch (error) { + return false; + } +})(); + +// `Uint8Array.prototype.toHex` method +// https://tc39.es/ecma262/#sec-uint8array.prototype.tohex +if (Uint8Array) $({ target: 'Uint8Array', proto: true, forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS }, { + toHex: function toHex() { + anUint8Array(this); + notDetached(this.buffer); + var result = $Array(this.length); + for (var i = 0, length = this.length; i < length; i++) { + var hex = numberToString(this[i], 16); + result[i] = hex.length === 1 ? '0' + hex : hex; + } + return join(result, ''); + } +}); + + +/***/ }), +/* 584 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); + +var fromCharCode = String.fromCharCode; +var charAt = uncurryThis(''.charAt); +var exec = uncurryThis(/./.exec); +var stringSlice = uncurryThis(''.slice); + +var hex2 = /^[\da-f]{2}$/i; +var hex4 = /^[\da-f]{4}$/i; + +// `unescape` method +// https://tc39.es/ecma262/#sec-unescape-string +$({ global: true }, { + unescape: function unescape(string) { + var str = toString(string); + var result = ''; + var length = str.length; + var index = 0; + var chr, part; + while (index < length) { + chr = charAt(str, index++); + if (chr === '%') { + if (charAt(str, index) === 'u') { + part = stringSlice(str, index + 1, index + 5); + if (exec(hex4, part)) { + result += fromCharCode(parseInt(part, 16)); + index += 5; + continue; + } + } else { + part = stringSlice(str, index, index + 2); + if (exec(hex2, part)) { + result += fromCharCode(parseInt(part, 16)); + index += 2; + continue; + } + } + } + result += chr; + } return result; + } +}); + + +/***/ }), +/* 585 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(586); + + +/***/ }), +/* 586 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var FREEZING = __webpack_require__(287); +var globalThis = __webpack_require__(4); +var uncurryThis = __webpack_require__(14); +var defineBuiltIns = __webpack_require__(214); +var InternalMetadataModule = __webpack_require__(292); +var collection = __webpack_require__(291); +var collectionWeak = __webpack_require__(587); +var isObject = __webpack_require__(20); +var enforceInternalState = __webpack_require__(51).enforce; +var fails = __webpack_require__(7); +var NATIVE_WEAK_MAP = __webpack_require__(52); + +var $Object = Object; +// eslint-disable-next-line es/no-array-isarray -- safe +var isArray = Array.isArray; +// eslint-disable-next-line es/no-object-isextensible -- safe +var isExtensible = $Object.isExtensible; +// eslint-disable-next-line es/no-object-isfrozen -- safe +var isFrozen = $Object.isFrozen; +// eslint-disable-next-line es/no-object-issealed -- safe +var isSealed = $Object.isSealed; +// eslint-disable-next-line es/no-object-freeze -- safe +var freeze = $Object.freeze; +// eslint-disable-next-line es/no-object-seal -- safe +var seal = $Object.seal; + +var IS_IE11 = !globalThis.ActiveXObject && 'ActiveXObject' in globalThis; +var InternalWeakMap; + +var wrapper = function (init) { + return function WeakMap() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}; + +// `WeakMap` constructor +// https://tc39.es/ecma262/#sec-weakmap-constructor +var $WeakMap = collection('WeakMap', wrapper, collectionWeak); +var WeakMapPrototype = $WeakMap.prototype; +var nativeSet = uncurryThis(WeakMapPrototype.set); + +// Chakra Edge bug: adding frozen arrays to WeakMap unfreeze them +var hasMSEdgeFreezingBug = function () { + return FREEZING && fails(function () { + var frozenArray = freeze([]); + nativeSet(new $WeakMap(), frozenArray, 1); + return !isFrozen(frozenArray); + }); +}; + +// IE11 WeakMap frozen keys fix +// We can't use feature detection because it crash some old IE builds +// https://github.com/zloirock/core-js/issues/485 +if (NATIVE_WEAK_MAP) if (IS_IE11) { + InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); + InternalMetadataModule.enable(); + var nativeDelete = uncurryThis(WeakMapPrototype['delete']); + var nativeHas = uncurryThis(WeakMapPrototype.has); + var nativeGet = uncurryThis(WeakMapPrototype.get); + defineBuiltIns(WeakMapPrototype, { + 'delete': function (key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceInternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeDelete(this, key) || state.frozen['delete'](key); + } return nativeDelete(this, key); + }, + has: function has(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceInternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas(this, key) || state.frozen.has(key); + } return nativeHas(this, key); + }, + get: function get(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceInternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas(this, key) ? nativeGet(this, key) : state.frozen.get(key); + } return nativeGet(this, key); + }, + set: function set(key, value) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceInternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + nativeHas(this, key) ? nativeSet(this, key, value) : state.frozen.set(key, value); + } else nativeSet(this, key, value); + return this; + } + }); +// Chakra Edge frozen keys fix +} else if (hasMSEdgeFreezingBug()) { + defineBuiltIns(WeakMapPrototype, { + set: function set(key, value) { + var arrayIntegrityLevel; + if (isArray(key)) { + if (isFrozen(key)) arrayIntegrityLevel = freeze; + else if (isSealed(key)) arrayIntegrityLevel = seal; + } + nativeSet(this, key, value); + if (arrayIntegrityLevel) arrayIntegrityLevel(key); + return this; + } + }); +} + + +/***/ }), +/* 587 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var defineBuiltIns = __webpack_require__(214); +var getWeakData = __webpack_require__(292).getWeakData; +var anInstance = __webpack_require__(215); +var anObject = __webpack_require__(46); +var isNullOrUndefined = __webpack_require__(17); +var isObject = __webpack_require__(20); +var iterate = __webpack_require__(136); +var ArrayIterationModule = __webpack_require__(83); +var hasOwn = __webpack_require__(38); +var InternalStateModule = __webpack_require__(51); + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var splice = uncurryThis([].splice); +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } +}; + +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: null + }); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + if (data) return data[state.id]; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } +}; + + +/***/ }), +/* 588 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var WeakMapHelpers = __webpack_require__(589); +var IS_PURE = __webpack_require__(36); + +var get = WeakMapHelpers.get; +var has = WeakMapHelpers.has; +var set = WeakMapHelpers.set; + +// `WeakMap.prototype.getOrInsert` method +// https://tc39.es/ecma262/#sec-weakmap.prototype.getorinsert +$({ target: 'WeakMap', proto: true, real: true, forced: IS_PURE }, { + getOrInsert: function getOrInsert(key, value) { + if (has(this, key)) return get(this, key); + set(this, key, value); + return value; + } +}); + + +/***/ }), +/* 589 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +// eslint-disable-next-line es/no-weak-map -- safe +var WeakMapPrototype = WeakMap.prototype; + +module.exports = { + // eslint-disable-next-line es/no-weak-map -- safe + WeakMap: WeakMap, + set: uncurryThis(WeakMapPrototype.set), + get: uncurryThis(WeakMapPrototype.get), + has: uncurryThis(WeakMapPrototype.has), + remove: uncurryThis(WeakMapPrototype['delete']) +}; + + +/***/ }), +/* 590 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aCallable = __webpack_require__(30); +var aWeakMap = __webpack_require__(591); +var aWeakKey = __webpack_require__(592); +var WeakMapHelpers = __webpack_require__(589); +var IS_PURE = __webpack_require__(36); + +var get = WeakMapHelpers.get; +var has = WeakMapHelpers.has; +var set = WeakMapHelpers.set; + +var FORCED = IS_PURE || !function () { + try { + // eslint-disable-next-line es/no-weak-map, no-throw-literal -- testing + if (WeakMap.prototype.getOrInsertComputed) new WeakMap().getOrInsertComputed(1, function () { throw 1; }); + } catch (error) { + // FF144 Nightly - Beta 3 bug + // https://bugzilla.mozilla.org/show_bug.cgi?id=1988369 + return error instanceof TypeError; + } +}(); + +// `WeakMap.prototype.getOrInsertComputed` method +// https://tc39.es/ecma262/#sec-weakmap.prototype.getorinsertcomputed +$({ target: 'WeakMap', proto: true, real: true, forced: FORCED }, { + getOrInsertComputed: function getOrInsertComputed(key, callbackfn) { + if (!IS_PURE) aWeakMap(this); + aWeakKey(key); + aCallable(callbackfn); + if (has(this, key)) return get(this, key); + var value = callbackfn(key); + set(this, key, value); + return value; + } +}); + + +/***/ }), +/* 591 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var has = __webpack_require__(589).has; + +// Perform ? RequireInternalSlot(M, [[WeakMapData]]) +module.exports = function (it) { + has(it); + return it; +}; + + +/***/ }), +/* 592 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var WeakMapHelpers = __webpack_require__(589); + +var weakmap = new WeakMapHelpers.WeakMap(); +var set = WeakMapHelpers.set; +var remove = WeakMapHelpers.remove; + +module.exports = function (key) { + set(weakmap, key, 1); + remove(weakmap, key); + return key; +}; + + +/***/ }), +/* 593 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(594); + + +/***/ }), +/* 594 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var collection = __webpack_require__(291); +var collectionWeak = __webpack_require__(587); + +// `WeakSet` constructor +// https://tc39.es/ecma262/#sec-weakset-constructor +collection('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionWeak); + + +/***/ }), +/* 595 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: remove from `core-js@4` +var $ = __webpack_require__(3); +var $filterReject = __webpack_require__(83).filterReject; +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.filterOut` method +// https://github.com/tc39/proposal-array-filtering +$({ target: 'Array', proto: true, forced: true }, { + filterOut: function filterOut(callbackfn /* , thisArg */) { + return $filterReject(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +addToUnscopables('filterOut'); + + +/***/ }), +/* 596 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $filterReject = __webpack_require__(83).filterReject; +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.filterReject` method +// https://github.com/tc39/proposal-array-filtering +$({ target: 'Array', proto: true, forced: true }, { + filterReject: function filterReject(callbackfn /* , thisArg */) { + return $filterReject(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +addToUnscopables('filterReject'); + + +/***/ }), +/* 597 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $group = __webpack_require__(598); +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.group` method +// https://github.com/tc39/proposal-array-grouping +$({ target: 'Array', proto: true }, { + group: function group(callbackfn /* , thisArg */) { + var thisArg = arguments.length > 1 ? arguments[1] : undefined; + return $group(this, callbackfn, thisArg); + } +}); + +addToUnscopables('group'); + + +/***/ }), +/* 598 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var uncurryThis = __webpack_require__(14); +var IndexedObject = __webpack_require__(13); +var toObject = __webpack_require__(39); +var toPropertyKey = __webpack_require__(18); +var lengthOfArrayLike = __webpack_require__(63); +var objectCreate = __webpack_require__(71); +var arrayFromConstructorAndList = __webpack_require__(204); + +var $Array = Array; +var push = uncurryThis([].push); + +module.exports = function ($this, callbackfn, that, specificConstructor) { + var O = toObject($this); + var self = IndexedObject(O); + var boundFunction = bind(callbackfn, that); + var target = objectCreate(null); + var length = lengthOfArrayLike(self); + var index = 0; + var Constructor, key, value; + for (;length > index; index++) { + value = self[index]; + key = toPropertyKey(boundFunction(value, index, O)); + // in some IE versions, `hasOwnProperty` returns incorrect result on integer keys + // but since it's a `null` prototype object, we can safely use `in` + if (key in target) push(target[key], value); + else target[key] = [value]; + } + // TODO: Remove this block from `core-js@4` + if (specificConstructor) { + Constructor = specificConstructor(O); + if (Constructor !== $Array) { + for (key in target) target[key] = arrayFromConstructorAndList(Constructor, target[key]); + } + } return target; +}; + + +/***/ }), +/* 599 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var $group = __webpack_require__(598); +var arrayMethodIsStrict = __webpack_require__(154); +var addToUnscopables = __webpack_require__(145); + +// `Array.prototype.groupBy` method +// https://github.com/tc39/proposal-array-grouping +// https://bugs.webkit.org/show_bug.cgi?id=236541 +$({ target: 'Array', proto: true, forced: !arrayMethodIsStrict('groupBy') }, { + groupBy: function groupBy(callbackfn /* , thisArg */) { + var thisArg = arguments.length > 1 ? arguments[1] : undefined; + return $group(this, callbackfn, thisArg); + } +}); + +addToUnscopables('groupBy'); + + +/***/ }), +/* 600 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var arrayMethodIsStrict = __webpack_require__(154); +var addToUnscopables = __webpack_require__(145); +var $groupToMap = __webpack_require__(601); +var IS_PURE = __webpack_require__(36); + +// `Array.prototype.groupByToMap` method +// https://github.com/tc39/proposal-array-grouping +// https://bugs.webkit.org/show_bug.cgi?id=236541 +$({ target: 'Array', proto: true, name: 'groupToMap', forced: IS_PURE || !arrayMethodIsStrict('groupByToMap') }, { + groupByToMap: $groupToMap +}); + +addToUnscopables('groupByToMap'); + + +/***/ }), +/* 601 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var bind = __webpack_require__(84); +var uncurryThis = __webpack_require__(14); +var IndexedObject = __webpack_require__(13); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var MapHelpers = __webpack_require__(297); + +var Map = MapHelpers.Map; +var mapGet = MapHelpers.get; +var mapHas = MapHelpers.has; +var mapSet = MapHelpers.set; +var push = uncurryThis([].push); + +// `Array.prototype.groupToMap` method +// https://github.com/tc39/proposal-array-grouping +module.exports = function groupToMap(callbackfn /* , thisArg */) { + var O = toObject(this); + var self = IndexedObject(O); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var map = new Map(); + var length = lengthOfArrayLike(self); + var index = 0; + var key, value; + for (;length > index; index++) { + value = self[index]; + key = boundFunction(value, index, O); + if (mapHas(map, key)) push(mapGet(map, key), value); + else mapSet(map, key, [value]); + } return map; +}; + + +/***/ }), +/* 602 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var addToUnscopables = __webpack_require__(145); +var $groupToMap = __webpack_require__(601); +var IS_PURE = __webpack_require__(36); + +// `Array.prototype.groupToMap` method +// https://github.com/tc39/proposal-array-grouping +$({ target: 'Array', proto: true, forced: IS_PURE }, { + groupToMap: $groupToMap +}); + +addToUnscopables('groupToMap'); + + +/***/ }), +/* 603 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isArray = __webpack_require__(88); + +// eslint-disable-next-line es/no-object-isfrozen -- safe +var isFrozen = Object.isFrozen; + +var isFrozenStringArray = function (array, allowUndefined) { + if (!isFrozen || !isArray(array) || !isFrozen(array)) return false; + var index = 0; + var length = array.length; + var element; + while (index < length) { + element = array[index++]; + if (!(typeof element == 'string' || (allowUndefined && element === undefined))) { + return false; + } + } return length !== 0; +}; + +// `Array.isTemplateObject` method +// https://github.com/tc39/proposal-array-is-template-object +$({ target: 'Array', stat: true, sham: true, forced: true }, { + isTemplateObject: function isTemplateObject(value) { + if (!isFrozenStringArray(value, true)) return false; + var raw = value.raw; + return isFrozenStringArray(raw, false) && raw.length === value.length; + } +}); + + +/***/ }), +/* 604 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var DESCRIPTORS = __webpack_require__(6); +var addToUnscopables = __webpack_require__(145); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var defineBuiltInAccessor = __webpack_require__(77); + +// `Array.prototype.lastIndex` getter +// https://github.com/tc39/proposal-array-last +if (DESCRIPTORS) { + defineBuiltInAccessor(Array.prototype, 'lastIndex', { + configurable: true, + get: function lastIndex() { + var O = toObject(this); + var len = lengthOfArrayLike(O); + return len === 0 ? 0 : len - 1; + } + }); + + addToUnscopables('lastIndex'); +} + + +/***/ }), +/* 605 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var DESCRIPTORS = __webpack_require__(6); +var addToUnscopables = __webpack_require__(145); +var toObject = __webpack_require__(39); +var lengthOfArrayLike = __webpack_require__(63); +var defineBuiltInAccessor = __webpack_require__(77); + +// `Array.prototype.lastIndex` accessor +// https://github.com/tc39/proposal-array-last +if (DESCRIPTORS) { + defineBuiltInAccessor(Array.prototype, 'lastItem', { + configurable: true, + get: function lastItem() { + var O = toObject(this); + var len = lengthOfArrayLike(O); + return len === 0 ? undefined : O[len - 1]; + }, + set: function lastItem(value) { + var O = toObject(this); + var len = lengthOfArrayLike(O); + return O[len === 0 ? 0 : len - 1] = value; + } + }); + + addToUnscopables('lastItem'); +} + + +/***/ }), +/* 606 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var addToUnscopables = __webpack_require__(145); +var uniqueBy = __webpack_require__(607); + +// `Array.prototype.uniqueBy` method +// https://github.com/tc39/proposal-array-unique +$({ target: 'Array', proto: true, forced: true }, { + uniqueBy: uniqueBy +}); + +addToUnscopables('uniqueBy'); + + +/***/ }), +/* 607 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aCallable = __webpack_require__(30); +var isNullOrUndefined = __webpack_require__(17); +var lengthOfArrayLike = __webpack_require__(63); +var toObject = __webpack_require__(39); +var createProperty = __webpack_require__(90); +var MapHelpers = __webpack_require__(297); +var iterate = __webpack_require__(608); + +var Map = MapHelpers.Map; +var mapHas = MapHelpers.has; +var mapSet = MapHelpers.set; + +// `Array.prototype.uniqueBy` method +// https://github.com/tc39/proposal-array-unique +module.exports = function uniqueBy(resolver) { + var that = toObject(this); + var length = lengthOfArrayLike(that); + var result = []; + var map = new Map(); + var resolverFunction = !isNullOrUndefined(resolver) ? aCallable(resolver) : function (value) { + return value; + }; + var index, item, key; + for (index = 0; index < length; index++) { + item = that[index]; + key = resolverFunction(item); + if (!mapHas(map, key)) mapSet(map, key, item); + } + index = 0; + iterate(map, function (value) { + createProperty(result, index++, value); + }); + return result; +}; + + +/***/ }), +/* 608 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var iterateSimple = __webpack_require__(456); +var MapHelpers = __webpack_require__(297); + +var Map = MapHelpers.Map; +var MapPrototype = MapHelpers.proto; +var forEach = uncurryThis(MapPrototype.forEach); +var entries = uncurryThis(MapPrototype.entries); +var next = entries(new Map()).next; + +module.exports = function (map, fn, interruptible) { + return interruptible ? iterateSimple({ iterator: entries(map), next: next }, function (entry) { + return fn(entry[1], entry[0]); + }) : forEach(map, fn); +}; + + +/***/ }), +/* 609 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anInstance = __webpack_require__(215); +var getPrototypeOf = __webpack_require__(134); +var createNonEnumerableProperty = __webpack_require__(43); +var hasOwn = __webpack_require__(38); +var wellKnownSymbol = __webpack_require__(33); +var AsyncIteratorPrototype = __webpack_require__(411); +var IS_PURE = __webpack_require__(36); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +var $TypeError = TypeError; + +var AsyncIteratorConstructor = function AsyncIterator() { + anInstance(this, AsyncIteratorPrototype); + if (getPrototypeOf(this) === AsyncIteratorPrototype) throw new $TypeError('Abstract class AsyncIterator not directly constructable'); +}; + +AsyncIteratorConstructor.prototype = AsyncIteratorPrototype; + +if (!hasOwn(AsyncIteratorPrototype, TO_STRING_TAG)) { + createNonEnumerableProperty(AsyncIteratorPrototype, TO_STRING_TAG, 'AsyncIterator'); +} + +if (IS_PURE || !hasOwn(AsyncIteratorPrototype, 'constructor') || AsyncIteratorPrototype.constructor === Object) { + createNonEnumerableProperty(AsyncIteratorPrototype, 'constructor', AsyncIteratorConstructor); +} + +// `AsyncIterator` constructor +// https://github.com/tc39/proposal-async-iterator-helpers +$({ global: true, constructor: true, forced: IS_PURE }, { + AsyncIterator: AsyncIteratorConstructor +}); + + +/***/ }), +/* 610 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var indexed = __webpack_require__(611); + +// `AsyncIterator.prototype.asIndexedPairs` method +// https://github.com/tc39/proposal-iterator-helpers +$({ target: 'AsyncIterator', name: 'indexed', proto: true, real: true, forced: true }, { + asIndexedPairs: indexed +}); + + +/***/ }), +/* 611 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var map = __webpack_require__(612); + +var callback = function (value, counter) { + return [counter, value]; +}; + +// `AsyncIterator.prototype.indexed` method +// https://github.com/tc39/proposal-iterator-helpers +module.exports = function indexed() { + return call(map, this, callback); +}; + + +/***/ }), +/* 612 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var getIteratorDirect = __webpack_require__(267); +var createAsyncIteratorProxy = __webpack_require__(613); +var createIterResultObject = __webpack_require__(179); +var closeAsyncIteration = __webpack_require__(413); + +var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) { + var state = this; + var iterator = state.iterator; + var mapper = state.mapper; + + return new Promise(function (resolve, reject) { + var doneAndReject = function (error) { + state.done = true; + reject(error); + }; + + var ifAbruptCloseAsyncIterator = function (error) { + closeAsyncIteration(iterator, doneAndReject, error, doneAndReject); + }; + + try { + Promise.resolve(anObject(call(state.next, iterator))).then(function (step) { + try { + if (anObject(step).done) { + state.done = true; + resolve(createIterResultObject(undefined, true)); + } else { + var value = step.value; + try { + var result = mapper(value, state.counter++); + + var handler = function (mapped) { + resolve(createIterResultObject(mapped, false)); + }; + + if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator); + else handler(result); + } catch (error2) { ifAbruptCloseAsyncIterator(error2); } + } + } catch (error) { doneAndReject(error); } + }, doneAndReject); + } catch (error) { doneAndReject(error); } + }); +}); + +// `AsyncIterator.prototype.map` method +// https://github.com/tc39/proposal-async-iterator-helpers +module.exports = function map(mapper) { + anObject(this); + aCallable(mapper); + return new AsyncIteratorProxy(getIteratorDirect(this), { + mapper: mapper + }); +}; + + +/***/ }), +/* 613 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var perform = __webpack_require__(391); +var anObject = __webpack_require__(46); +var create = __webpack_require__(71); +var createNonEnumerableProperty = __webpack_require__(43); +var defineBuiltIns = __webpack_require__(214); +var wellKnownSymbol = __webpack_require__(33); +var InternalStateModule = __webpack_require__(51); +var getBuiltIn = __webpack_require__(23); +var getMethod = __webpack_require__(29); +var AsyncIteratorPrototype = __webpack_require__(411); +var createIterResultObject = __webpack_require__(179); + +var Promise = getBuiltIn('Promise'); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var ASYNC_ITERATOR_HELPER = 'AsyncIteratorHelper'; +var WRAP_FOR_VALID_ASYNC_ITERATOR = 'WrapForValidAsyncIterator'; +var setInternalState = InternalStateModule.set; + +var createAsyncIteratorProxyPrototype = function (IS_ITERATOR) { + var IS_GENERATOR = !IS_ITERATOR; + var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ASYNC_ITERATOR : ASYNC_ITERATOR_HELPER); + + var getStateOrEarlyExit = function (that) { + var stateCompletion = perform(function () { + return getInternalState(that); + }); + + var stateError = stateCompletion.error; + var state = stateCompletion.value; + + if (stateError || (IS_GENERATOR && state.done)) { + return { exit: true, value: stateError ? Promise.reject(state) : Promise.resolve(createIterResultObject(undefined, true)) }; + } return { exit: false, value: state }; + }; + + return defineBuiltIns(create(AsyncIteratorPrototype), { + next: function next() { + var stateCompletion = getStateOrEarlyExit(this); + var state = stateCompletion.value; + if (stateCompletion.exit) return state; + var handlerCompletion = perform(function () { + return anObject(state.nextHandler(Promise)); + }); + var handlerError = handlerCompletion.error; + var value = handlerCompletion.value; + if (handlerError) state.done = true; + return handlerError ? Promise.reject(value) : Promise.resolve(value); + }, + 'return': function () { + var stateCompletion = getStateOrEarlyExit(this); + var state = stateCompletion.value; + if (stateCompletion.exit) return state; + state.done = true; + var iterator = state.iterator; + var inner = state.inner; + var returnMethod, result; + var closeOuterIterator = function () { + var completion = perform(function () { + return getMethod(iterator, 'return'); + }); + returnMethod = result = completion.value; + if (completion.error) return Promise.reject(result); + if (returnMethod === undefined) return Promise.resolve(createIterResultObject(undefined, true)); + completion = perform(function () { + return call(returnMethod, iterator); + }); + result = completion.value; + if (completion.error) return Promise.reject(result); + return IS_ITERATOR ? Promise.resolve(result) : Promise.resolve(result).then(function (resolved) { + anObject(resolved); + return createIterResultObject(undefined, true); + }); + }; + + var closeAndReject = function (error) { + return closeOuterIterator().then(function () { + throw error; + }, function () { + throw error; + }); + }; + + if (inner) { + var innerIterator = inner.iterator; + var innerReturn; + var completion = perform(function () { + innerReturn = getMethod(innerIterator, 'return'); + if (innerReturn) return call(innerReturn, innerIterator); + }); + if (completion.error) return closeAndReject(completion.value); + if (innerReturn) { + return Promise.resolve(completion.value).then(function (innerResult) { + try { + anObject(innerResult); + } catch (error) { + return closeAndReject(error); + } + return closeOuterIterator(); + }, closeAndReject); + } + } + + return closeOuterIterator(); + } + }); +}; + +var WrapForValidAsyncIteratorPrototype = createAsyncIteratorProxyPrototype(true); +var AsyncIteratorHelperPrototype = createAsyncIteratorProxyPrototype(false); + +createNonEnumerableProperty(AsyncIteratorHelperPrototype, TO_STRING_TAG, 'Async Iterator Helper'); + +module.exports = function (nextHandler, IS_ITERATOR) { + var AsyncIteratorProxy = function AsyncIterator(record, state) { + if (state) { + state.iterator = record.iterator; + state.next = record.next; + } else state = record; + state.type = IS_ITERATOR ? WRAP_FOR_VALID_ASYNC_ITERATOR : ASYNC_ITERATOR_HELPER; + state.nextHandler = nextHandler; + state.counter = 0; + state.done = false; + setInternalState(this, state); + }; + + AsyncIteratorProxy.prototype = IS_ITERATOR ? WrapForValidAsyncIteratorPrototype : AsyncIteratorHelperPrototype; + + return AsyncIteratorProxy; +}; + + +/***/ }), +/* 614 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var notANaN = __webpack_require__(268); +var toPositiveInteger = __webpack_require__(269); +var createAsyncIteratorProxy = __webpack_require__(613); +var createIterResultObject = __webpack_require__(179); + +var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) { + var state = this; + + return new Promise(function (resolve, reject) { + var doneAndReject = function (error) { + state.done = true; + reject(error); + }; + + var loop = function () { + try { + Promise.resolve(anObject(call(state.next, state.iterator))).then(function (step) { + try { + if (anObject(step).done) { + state.done = true; + resolve(createIterResultObject(undefined, true)); + } else if (state.remaining) { + state.remaining--; + loop(); + } else resolve(createIterResultObject(step.value, false)); + } catch (err) { doneAndReject(err); } + }, doneAndReject); + } catch (error) { doneAndReject(error); } + }; + + loop(); + }); +}); + +// `AsyncIterator.prototype.drop` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + drop: function drop(limit) { + anObject(this); + var remaining = toPositiveInteger(notANaN(+limit)); + return new AsyncIteratorProxy(getIteratorDirect(this), { + remaining: remaining + }); + } +}); + + +/***/ }), +/* 615 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $every = __webpack_require__(412).every; + +// `AsyncIterator.prototype.every` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + every: function every(predicate) { + return $every(this, predicate); + } +}); + + +/***/ }), +/* 616 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var getIteratorDirect = __webpack_require__(267); +var createAsyncIteratorProxy = __webpack_require__(613); +var createIterResultObject = __webpack_require__(179); +var closeAsyncIteration = __webpack_require__(413); + +var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) { + var state = this; + var iterator = state.iterator; + var predicate = state.predicate; + + return new Promise(function (resolve, reject) { + var doneAndReject = function (error) { + state.done = true; + reject(error); + }; + + var ifAbruptCloseAsyncIterator = function (error) { + closeAsyncIteration(iterator, doneAndReject, error, doneAndReject); + }; + + var loop = function () { + try { + Promise.resolve(anObject(call(state.next, iterator))).then(function (step) { + try { + if (anObject(step).done) { + state.done = true; + resolve(createIterResultObject(undefined, true)); + } else { + var value = step.value; + try { + var result = predicate(value, state.counter++); + + var handler = function (selected) { + selected ? resolve(createIterResultObject(value, false)) : loop(); + }; + + if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator); + else handler(result); + } catch (error3) { ifAbruptCloseAsyncIterator(error3); } + } + } catch (error2) { doneAndReject(error2); } + }, doneAndReject); + } catch (error) { doneAndReject(error); } + }; + + loop(); + }); +}); + +// `AsyncIterator.prototype.filter` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + filter: function filter(predicate) { + anObject(this); + aCallable(predicate); + return new AsyncIteratorProxy(getIteratorDirect(this), { + predicate: predicate + }); + } +}); + + +/***/ }), +/* 617 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $find = __webpack_require__(412).find; + +// `AsyncIterator.prototype.find` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + find: function find(predicate) { + return $find(this, predicate); + } +}); + + +/***/ }), +/* 618 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var getIteratorDirect = __webpack_require__(267); +var createAsyncIteratorProxy = __webpack_require__(613); +var createIterResultObject = __webpack_require__(179); +var getAsyncIteratorFlattenable = __webpack_require__(619); +var closeAsyncIteration = __webpack_require__(413); + +var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) { + var state = this; + var iterator = state.iterator; + var mapper = state.mapper; + + return new Promise(function (resolve, reject) { + var doneAndReject = function (error) { + state.done = true; + reject(error); + }; + + var ifAbruptCloseAsyncIterator = function (error) { + closeAsyncIteration(iterator, doneAndReject, error, doneAndReject); + }; + + var outerLoop = function () { + try { + Promise.resolve(anObject(call(state.next, iterator))).then(function (step) { + try { + if (anObject(step).done) { + state.done = true; + resolve(createIterResultObject(undefined, true)); + } else { + var value = step.value; + try { + var result = mapper(value, state.counter++); + + var handler = function (mapped) { + try { + state.inner = getAsyncIteratorFlattenable(mapped); + innerLoop(); + } catch (error4) { ifAbruptCloseAsyncIterator(error4); } + }; + + if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator); + else handler(result); + } catch (error3) { ifAbruptCloseAsyncIterator(error3); } + } + } catch (error2) { doneAndReject(error2); } + }, doneAndReject); + } catch (error) { doneAndReject(error); } + }; + + var innerLoop = function () { + var inner = state.inner; + if (inner) { + try { + Promise.resolve(anObject(call(inner.next, inner.iterator))).then(function (result) { + try { + if (anObject(result).done) { + state.inner = null; + outerLoop(); + } else resolve(createIterResultObject(result.value, false)); + } catch (error1) { ifAbruptCloseAsyncIterator(error1); } + }, ifAbruptCloseAsyncIterator); + } catch (error) { ifAbruptCloseAsyncIterator(error); } + } else outerLoop(); + }; + + innerLoop(); + }); +}); + +// `AsyncIterator.prototype.flatMap` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + flatMap: function flatMap(mapper) { + anObject(this); + aCallable(mapper); + return new AsyncIteratorProxy(getIteratorDirect(this), { + mapper: mapper, + inner: null + }); + } +}); + + +/***/ }), +/* 619 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var isCallable = __webpack_require__(21); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var getIteratorMethod = __webpack_require__(140); +var getMethod = __webpack_require__(29); +var wellKnownSymbol = __webpack_require__(33); +var AsyncFromSyncIterator = __webpack_require__(410); + +var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator'); + +module.exports = function (obj) { + var object = anObject(obj); + var alreadyAsync = true; + var method = getMethod(object, ASYNC_ITERATOR); + var iterator; + if (!isCallable(method)) { + method = getIteratorMethod(object); + alreadyAsync = false; + } + if (method !== undefined) { + iterator = call(method, object); + } else { + iterator = object; + alreadyAsync = true; + } + anObject(iterator); + return getIteratorDirect(alreadyAsync ? iterator : new AsyncFromSyncIterator(getIteratorDirect(iterator))); +}; + + +/***/ }), +/* 620 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $forEach = __webpack_require__(412).forEach; + +// `AsyncIterator.prototype.forEach` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + forEach: function forEach(fn) { + return $forEach(this, fn); + } +}); + + +/***/ }), +/* 621 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var toObject = __webpack_require__(39); +var isPrototypeOf = __webpack_require__(24); +var getAsyncIteratorFlattenable = __webpack_require__(619); +var AsyncIteratorPrototype = __webpack_require__(411); +var WrapAsyncIterator = __webpack_require__(622); + +// `AsyncIterator.from` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', stat: true, forced: true }, { + from: function from(O) { + var iteratorRecord = getAsyncIteratorFlattenable(typeof O == 'string' ? toObject(O) : O); + return isPrototypeOf(AsyncIteratorPrototype, iteratorRecord.iterator) + ? iteratorRecord.iterator + : new WrapAsyncIterator(iteratorRecord); + } +}); + + +/***/ }), +/* 622 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var createAsyncIteratorProxy = __webpack_require__(613); + +module.exports = createAsyncIteratorProxy(function () { + return call(this.next, this.iterator); +}, true); + + +/***/ }), +/* 623 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var indexed = __webpack_require__(611); + +// `AsyncIterator.prototype.indexed` method +// https://github.com/tc39/proposal-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + indexed: indexed +}); + + +/***/ }), +/* 624 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var map = __webpack_require__(612); + +// `AsyncIterator.prototype.map` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + map: map +}); + + + +/***/ }), +/* 625 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var getBuiltIn = __webpack_require__(23); +var getIteratorDirect = __webpack_require__(267); +var closeAsyncIteration = __webpack_require__(413); + +var Promise = getBuiltIn('Promise'); +var $TypeError = TypeError; + +// `AsyncIterator.prototype.reduce` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + reduce: function reduce(reducer /* , initialValue */) { + anObject(this); + aCallable(reducer); + var record = getIteratorDirect(this); + var iterator = record.iterator; + var next = record.next; + var noInitial = arguments.length < 2; + var accumulator = noInitial ? undefined : arguments[1]; + var counter = 0; + + return new Promise(function (resolve, reject) { + var ifAbruptCloseAsyncIterator = function (error) { + closeAsyncIteration(iterator, reject, error, reject); + }; + + var loop = function () { + try { + Promise.resolve(anObject(call(next, iterator))).then(function (step) { + try { + if (anObject(step).done) { + noInitial ? reject(new $TypeError('Reduce of empty iterator with no initial value')) : resolve(accumulator); + } else { + var value = step.value; + if (noInitial) { + noInitial = false; + accumulator = value; + counter++; + loop(); + } else try { + var result = reducer(accumulator, value, counter++); + + var handler = function ($result) { + accumulator = $result; + loop(); + }; + + if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator); + else handler(result); + } catch (error3) { ifAbruptCloseAsyncIterator(error3); } + } + } catch (error2) { reject(error2); } + }, reject); + } catch (error) { reject(error); } + }; + + loop(); + }); + } +}); + + +/***/ }), +/* 626 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $some = __webpack_require__(412).some; + +// `AsyncIterator.prototype.some` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + some: function some(predicate) { + return $some(this, predicate); + } +}); + + +/***/ }), +/* 627 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var getIteratorDirect = __webpack_require__(267); +var getMethod = __webpack_require__(29); +var notANaN = __webpack_require__(268); +var toPositiveInteger = __webpack_require__(269); +var createAsyncIteratorProxy = __webpack_require__(613); +var createIterResultObject = __webpack_require__(179); + +var AsyncIteratorProxy = createAsyncIteratorProxy(function (Promise) { + var state = this; + var iterator = state.iterator; + var returnMethod; + + if (!state.remaining--) { + var resultDone = createIterResultObject(undefined, true); + state.done = true; + returnMethod = getMethod(iterator, 'return'); + if (returnMethod !== undefined) { + return Promise.resolve(call(returnMethod, iterator)).then(function (result) { + anObject(result); + return resultDone; + }); + } + return resultDone; + } return Promise.resolve(call(state.next, iterator)).then(function (step) { + if (anObject(step).done) { + state.done = true; + return createIterResultObject(undefined, true); + } return createIterResultObject(step.value, false); + }).then(null, function (error) { + state.done = true; + throw error; + }); +}); + +// `AsyncIterator.prototype.take` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + take: function take(limit) { + anObject(this); + var remaining = toPositiveInteger(notANaN(+limit)); + return new AsyncIteratorProxy(getIteratorDirect(this), { + remaining: remaining + }); + } +}); + + +/***/ }), +/* 628 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $toArray = __webpack_require__(412).toArray; + +// `AsyncIterator.prototype.toArray` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'AsyncIterator', proto: true, real: true, forced: true }, { + toArray: function toArray() { + return $toArray(this, undefined, []); + } +}); + + +/***/ }), +/* 629 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-bigint -- safe */ +var $ = __webpack_require__(3); +var NumericRangeIterator = __webpack_require__(630); + +// `BigInt.range` method +// https://github.com/tc39/proposal-iterator.range +// TODO: Remove from `core-js@4` +if (typeof BigInt == 'function') { + $({ target: 'BigInt', stat: true, forced: true }, { + range: function range(start, end, option) { + return new NumericRangeIterator(start, end, option, 'bigint', BigInt(0), BigInt(1)); + } + }); +} + + +/***/ }), +/* 630 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-iterator.range +var InternalStateModule = __webpack_require__(51); +var createIteratorConstructor = __webpack_require__(177); +var createIterResultObject = __webpack_require__(179); +var isNullOrUndefined = __webpack_require__(17); +var isObject = __webpack_require__(20); +var defineBuiltInAccessor = __webpack_require__(77); +var DESCRIPTORS = __webpack_require__(6); + +var INCORRECT_RANGE = 'Incorrect Iterator.range arguments'; +var NUMERIC_RANGE_ITERATOR = 'NumericRangeIterator'; + +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(NUMERIC_RANGE_ITERATOR); + +var $RangeError = RangeError; +var $TypeError = TypeError; + +var $RangeIterator = createIteratorConstructor(function NumericRangeIterator(start, end, option, type, zero, one) { + // eslint-disable-next-line no-self-compare -- NaN check + if (start !== start || end !== end) { + throw new $RangeError(INCORRECT_RANGE); + } + // TODO: Drop the first `typeof` check after removing legacy methods in `core-js@4` + if (typeof start != type || (end !== Infinity && end !== -Infinity && typeof end != type)) { + throw new $TypeError(INCORRECT_RANGE); + } + if (start === Infinity || start === -Infinity) { + throw new $RangeError(INCORRECT_RANGE); + } + var ifIncrease = end > start; + var inclusiveEnd = false; + var step; + if (isNullOrUndefined(option)) { + step = undefined; + } else if (isObject(option)) { + step = option.step; + inclusiveEnd = !!option.inclusive; + } else if (typeof option == type) { + step = option; + } else { + throw new $TypeError(INCORRECT_RANGE); + } + if (isNullOrUndefined(step)) { + step = ifIncrease ? one : -one; + } + if (typeof step != type) { + throw new $TypeError(INCORRECT_RANGE); + } + // eslint-disable-next-line no-self-compare -- NaN check + if (step !== step || step === Infinity || step === -Infinity || (step === zero && start !== end)) { + throw new $RangeError(INCORRECT_RANGE); + } + var hitsEnd = end > start !== step > zero; + setInternalState(this, { + type: NUMERIC_RANGE_ITERATOR, + start: start, + end: end, + step: step, + inclusive: inclusiveEnd, + hitsEnd: hitsEnd, + currentCount: zero, + zero: zero + }); + if (!DESCRIPTORS) { + this.start = start; + this.end = end; + this.step = step; + this.inclusive = inclusiveEnd; + } +}, NUMERIC_RANGE_ITERATOR, function next() { + var state = getInternalState(this); + if (state.hitsEnd) return createIterResultObject(undefined, true); + var start = state.start; + var end = state.end; + var step = state.step; + var currentYieldingValue = start + (step * state.currentCount++); + if (currentYieldingValue === end) state.hitsEnd = true; + var inclusiveEnd = state.inclusive; + var endCondition; + if (end > start) { + endCondition = inclusiveEnd ? currentYieldingValue > end : currentYieldingValue >= end; + } else { + endCondition = inclusiveEnd ? end > currentYieldingValue : end >= currentYieldingValue; + } + if (endCondition) { + state.hitsEnd = true; + return createIterResultObject(undefined, true); + } return createIterResultObject(currentYieldingValue, false); +}); + +var addGetter = function (key) { + defineBuiltInAccessor($RangeIterator.prototype, key, { + get: function () { + return getInternalState(this)[key]; + }, + set: function () { /* empty */ }, + configurable: true, + enumerable: false + }); +}; + +if (DESCRIPTORS) { + addGetter('start'); + addGetter('end'); + addGetter('inclusive'); + addGetter('step'); +} + +module.exports = $RangeIterator; + + +/***/ }), +/* 631 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var apply = __webpack_require__(95); +var getCompositeKeyNode = __webpack_require__(632); +var getBuiltIn = __webpack_require__(23); +var create = __webpack_require__(71); + +var $Object = Object; + +var initializer = function () { + var freeze = getBuiltIn('Object', 'freeze'); + return freeze ? freeze(create(null)) : create(null); +}; + +// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey +$({ global: true, forced: true }, { + compositeKey: function compositeKey() { + return apply(getCompositeKeyNode, $Object, arguments).get('object', initializer); + } +}); + + +/***/ }), +/* 632 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` +__webpack_require__(289); +__webpack_require__(585); +var getBuiltIn = __webpack_require__(23); +var create = __webpack_require__(71); +var isObject = __webpack_require__(20); + +var $Object = Object; +var $TypeError = TypeError; +var Map = getBuiltIn('Map'); +var WeakMap = getBuiltIn('WeakMap'); + +var Node = function () { + // keys + this.object = null; + this.symbol = null; + // child nodes + this.primitives = null; + this.objectsByIndex = create(null); +}; + +Node.prototype.get = function (key, initializer) { + return this[key] || (this[key] = initializer()); +}; + +Node.prototype.next = function (i, it, IS_OBJECT) { + var store = IS_OBJECT + ? this.objectsByIndex[i] || (this.objectsByIndex[i] = new WeakMap()) + : this.primitives || (this.primitives = new Map()); + var entry = store.get(it); + if (!entry) store.set(it, entry = new Node()); + return entry; +}; + +var root = new Node(); + +module.exports = function () { + var active = root; + var length = arguments.length; + var i, it; + // for prevent leaking, start from objects + for (i = 0; i < length; i++) { + if (isObject(it = arguments[i])) active = active.next(i, it, true); + } + if (this === $Object && active === root) throw new $TypeError('Composite keys must contain a non-primitive component'); + for (i = 0; i < length; i++) { + if (!isObject(it = arguments[i])) active = active.next(i, it, false); + } return active; +}; + + +/***/ }), +/* 633 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getCompositeKeyNode = __webpack_require__(632); +var getBuiltIn = __webpack_require__(23); +var apply = __webpack_require__(95); + +// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey +$({ global: true, forced: true }, { + compositeSymbol: function compositeSymbol() { + if (arguments.length === 1 && typeof arguments[0] == 'string') return getBuiltIn('Symbol')['for'](arguments[0]); + return apply(getCompositeKeyNode, null, arguments).get('symbol', getBuiltIn('Symbol')); + } +}); + + +/***/ }), +/* 634 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); + +// eslint-disable-next-line es/no-typed-arrays -- safe +var getUint8 = uncurryThis(DataView.prototype.getUint8); + +// `DataView.prototype.getUint8Clamped` method +// https://github.com/tc39/proposal-dataview-get-set-uint8clamped +$({ target: 'DataView', proto: true, forced: true }, { + getUint8Clamped: function getUint8Clamped(byteOffset) { + return getUint8(this, byteOffset); + } +}); + + +/***/ }), +/* 635 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aDataView = __webpack_require__(229); +var toIndex = __webpack_require__(216); +var toUint8Clamped = __webpack_require__(528); + +// eslint-disable-next-line es/no-typed-arrays -- safe +var setUint8 = uncurryThis(DataView.prototype.setUint8); + +// `DataView.prototype.setUint8Clamped` method +// https://github.com/tc39/proposal-dataview-get-set-uint8clamped +$({ target: 'DataView', proto: true, forced: true }, { + setUint8Clamped: function setUint8Clamped(byteOffset, value) { + setUint8( + aDataView(this), + toIndex(byteOffset), + toUint8Clamped(value) + ); + } +}); + + +/***/ }), +/* 636 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var demethodize = __webpack_require__(637); + +// `Function.prototype.demethodize` method +// https://github.com/js-choi/proposal-function-demethodize +$({ target: 'Function', proto: true, forced: true }, { + demethodize: demethodize +}); + + +/***/ }), +/* 637 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var aCallable = __webpack_require__(30); + +module.exports = function demethodize() { + return uncurryThis(aCallable(this)); +}; + + +/***/ }), +/* 638 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var $isCallable = __webpack_require__(21); +var inspectSource = __webpack_require__(50); +var hasOwn = __webpack_require__(38); +var DESCRIPTORS = __webpack_require__(6); + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var classRegExp = /^\s*class\b/; +var exec = uncurryThis(classRegExp.exec); + +var isClassConstructor = function (argument) { + try { + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + if (!DESCRIPTORS || !exec(classRegExp, inspectSource(argument))) return false; + } catch (error) { /* empty */ } + var prototype = getOwnPropertyDescriptor(argument, 'prototype'); + return !!prototype && hasOwn(prototype, 'writable') && !prototype.writable; +}; + +// `Function.isCallable` method +// https://github.com/caitp/TC39-Proposals/blob/trunk/tc39-reflect-isconstructor-iscallable.md +$({ target: 'Function', stat: true, sham: true, forced: true }, { + isCallable: function isCallable(argument) { + return $isCallable(argument) && !isClassConstructor(argument); + } +}); + + +/***/ }), +/* 639 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isConstructor = __webpack_require__(89); + +// `Function.isConstructor` method +// https://github.com/caitp/TC39-Proposals/blob/trunk/tc39-reflect-isconstructor-iscallable.md +$({ target: 'Function', stat: true, forced: true }, { + isConstructor: isConstructor +}); + + +/***/ }), +/* 640 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(33); +var defineProperty = __webpack_require__(44).f; + +var METADATA = wellKnownSymbol('metadata'); +var FunctionPrototype = Function.prototype; + +// Function.prototype[@@metadata] +// https://github.com/tc39/proposal-decorator-metadata +if (FunctionPrototype[METADATA] === undefined) { + defineProperty(FunctionPrototype, METADATA, { + value: null + }); +} + + +/***/ }), +/* 641 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var demethodize = __webpack_require__(637); + +// `Function.prototype.unThis` method +// https://github.com/js-choi/proposal-function-demethodize +// TODO: Remove from `core-js@4` +$({ target: 'Function', proto: true, forced: true, name: 'demethodize' }, { + unThis: demethodize +}); + + +/***/ }), +/* 642 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var indexed = __webpack_require__(643); + +// `Iterator.prototype.asIndexedPairs` method +// https://github.com/tc39/proposal-iterator-helpers +$({ target: 'Iterator', name: 'indexed', proto: true, real: true, forced: true }, { + asIndexedPairs: indexed +}); + + +/***/ }), +/* 643 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +__webpack_require__(279); +var call = __webpack_require__(8); +var map = __webpack_require__(178).IteratorPrototype.map; + +var callback = function (value, counter) { + return [counter, value]; +}; + +// `Iterator.prototype.indexed` method +// https://github.com/tc39/proposal-iterator-helpers +module.exports = function indexed() { + return call(map, this, callback); +}; + + +/***/ }), +/* 644 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var call = __webpack_require__(8); +var createIteratorProxy = __webpack_require__(263); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var uncurryThis = __webpack_require__(14); + +var $RangeError = RangeError; +var push = uncurryThis([].push); + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + var next = this.next; + var chunkSize = this.chunkSize; + var buffer = []; + var result, done; + while (true) { + result = anObject(call(next, iterator)); + done = !!result.done; + if (done) { + if (buffer.length) return buffer; + this.done = true; + return; + } + push(buffer, result.value); + if (buffer.length === chunkSize) return buffer; + } +}); + +// `Iterator.prototype.chunks` method +// https://github.com/tc39/proposal-iterator-chunking +$({ target: 'Iterator', proto: true, real: true, forced: true }, { + chunks: function chunks(chunkSize) { + var O = anObject(this); + if (typeof chunkSize != 'number' || !chunkSize || chunkSize >>> 0 !== chunkSize) { + return iteratorClose(O, 'throw', new $RangeError('chunkSize must be integer in [1, 2^32-1]')); + } + return new IteratorProxy(getIteratorDirect(O), { + chunkSize: chunkSize + }); + } +}); + + +/***/ }), +/* 645 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var indexed = __webpack_require__(643); + +// `Iterator.prototype.indexed` method +// https://github.com/tc39/proposal-iterator-helpers +$({ target: 'Iterator', proto: true, real: true, forced: true }, { + indexed: indexed +}); + + +/***/ }), +/* 646 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-bigint -- safe */ +var $ = __webpack_require__(3); +var NumericRangeIterator = __webpack_require__(630); + +var $TypeError = TypeError; + +// `Iterator.range` method +// https://github.com/tc39/proposal-iterator.range +$({ target: 'Iterator', stat: true, forced: true }, { + range: function range(start, end, option) { + if (typeof start == 'number') return new NumericRangeIterator(start, end, option, 'number', 0, 1); + if (typeof start == 'bigint') return new NumericRangeIterator(start, end, option, 'bigint', BigInt(0), BigInt(1)); + throw new $TypeError('Incorrect Iterator.range arguments'); + } +}); + + +/***/ }), +/* 647 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var iteratorWindow = __webpack_require__(648); + +// `Iterator.prototype.sliding` method +// https://github.com/tc39/proposal-iterator-chunking +$({ target: 'Iterator', proto: true, real: true, forced: true }, { + sliding: function sliding(windowSize) { + return iteratorWindow(this, windowSize, 'allow-partial'); + } +}); + + +/***/ }), +/* 648 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); +var call = __webpack_require__(8); +var createIteratorProxy = __webpack_require__(263); +var createIterResultObject = __webpack_require__(179); +var getIteratorDirect = __webpack_require__(267); +var iteratorClose = __webpack_require__(141); +var uncurryThis = __webpack_require__(14); + +var $RangeError = RangeError; +var $TypeError = TypeError; +var push = uncurryThis([].push); +var slice = uncurryThis([].slice); +var ALLOW_PARTIAL = 'allow-partial'; + +var IteratorProxy = createIteratorProxy(function () { + var iterator = this.iterator; + var next = this.next; + var buffer = this.buffer; + var windowSize = this.windowSize; + var allowPartial = this.allowPartial; + var result, done; + while (true) { + result = anObject(call(next, iterator)); + done = this.done = !!result.done; + if (allowPartial && done && buffer.length && buffer.length < windowSize) return createIterResultObject(slice(buffer, 0), false); + if (done) return createIterResultObject(undefined, true); + + if (buffer.length === windowSize) this.buffer = buffer = slice(buffer, 1); + push(buffer, result.value); + if (buffer.length === windowSize) return createIterResultObject(slice(buffer, 0), false); + } +}, false, true); + +// `Iterator.prototype.windows` and obsolete `Iterator.prototype.sliding` methods +// https://github.com/tc39/proposal-iterator-chunking +module.exports = function (O, windowSize, undersized) { + anObject(O); + if (typeof windowSize != 'number' || !windowSize || windowSize >>> 0 !== windowSize) { + return iteratorClose(O, 'throw', new $RangeError('`windowSize` must be integer in [1, 2^32-1]')); + } + if (undersized !== undefined && undersized !== 'only-full' && undersized !== ALLOW_PARTIAL) { + return iteratorClose(O, 'throw', new $TypeError('Incorrect `undersized` argument')); + } + return new IteratorProxy(getIteratorDirect(O), { + windowSize: windowSize, + buffer: [], + allowPartial: undersized === ALLOW_PARTIAL + }); +}; + + +/***/ }), +/* 649 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var AsyncFromSyncIterator = __webpack_require__(410); +var WrapAsyncIterator = __webpack_require__(622); +var getIteratorDirect = __webpack_require__(267); + +// `Iterator.prototype.toAsync` method +// https://github.com/tc39/proposal-async-iterator-helpers +$({ target: 'Iterator', proto: true, real: true, forced: true }, { + toAsync: function toAsync() { + return new WrapAsyncIterator(getIteratorDirect(new AsyncFromSyncIterator(getIteratorDirect(anObject(this))))); + } +}); + + +/***/ }), +/* 650 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var iteratorWindow = __webpack_require__(648); + +// `Iterator.prototype.windows` method +// https://github.com/tc39/proposal-iterator-chunking +$({ target: 'Iterator', proto: true, real: true, forced: true }, { + windows: function windows(windowSize /* , undersized */) { + return iteratorWindow(this, windowSize, arguments.length < 2 ? undefined : arguments[1]); + } +}); + + +/***/ }), +/* 651 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var anObjectOrUndefined = __webpack_require__(574); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var getIteratorRecord = __webpack_require__(652); +var getIteratorFlattenable = __webpack_require__(276); +var getModeOption = __webpack_require__(653); +var iteratorClose = __webpack_require__(141); +var iteratorCloseAll = __webpack_require__(264); +var iteratorZip = __webpack_require__(654); +var IS_PURE = __webpack_require__(36); + +var concat = uncurryThis([].concat); +var push = uncurryThis([].push); +var THROW = 'throw'; + +// `Iterator.zip` method +// https://github.com/tc39/proposal-joint-iteration +$({ target: 'Iterator', stat: true, forced: IS_PURE }, { + zip: function zip(iterables /* , options */) { + anObject(iterables); + var options = arguments.length > 1 ? anObjectOrUndefined(arguments[1]) : undefined; + var mode = getModeOption(options); + var paddingOption = mode === 'longest' ? anObjectOrUndefined(options && options.padding) : undefined; + + var iters = []; + var padding = []; + var inputIter = getIteratorRecord(iterables); + var iter, done, next; + while (!done) { + try { + next = anObject(call(inputIter.next, inputIter.iterator)); + done = next.done; + } catch (error) { + return iteratorCloseAll(iters, THROW, error); + } + if (!done) { + try { + iter = getIteratorFlattenable(next.value, false); + } catch (error) { + return iteratorCloseAll(concat([inputIter], iters), THROW, error); + } + push(iters, iter); + } + } + + var iterCount = iters.length; + var i, paddingDone, paddingIter; + if (mode === 'longest') { + if (paddingOption === undefined) { + for (i = 0; i < iterCount; i++) push(padding, undefined); + } else { + try { + paddingIter = getIteratorRecord(paddingOption); + } catch (error) { + return iteratorCloseAll(iters, THROW, error); + } + var usingIterator = true; + for (i = 0; i < iterCount; i++) { + if (usingIterator) { + try { + next = anObject(call(paddingIter.next, paddingIter.iterator)); + paddingDone = next.done; + next = next.value; + } catch (error) { + return iteratorCloseAll(iters, THROW, error); + } + if (paddingDone) { + usingIterator = false; + } else { + push(padding, next); + } + } else { + push(padding, undefined); + } + } + + if (usingIterator) { + try { + iteratorClose(paddingIter.iterator, 'normal'); + } catch (error) { + return iteratorCloseAll(iters, THROW, error); + } + } + } + } + + return iteratorZip(iters, mode, padding); + } +}); + + +/***/ }), +/* 652 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getIterator = __webpack_require__(139); +var getIteratorDirect = __webpack_require__(267); + +module.exports = function (argument) { + return getIteratorDirect(getIterator(argument)); +}; + + +/***/ }), +/* 653 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $TypeError = TypeError; + +module.exports = function (options) { + var mode = options && options.mode; + if (mode === undefined || mode === 'shortest' || mode === 'longest' || mode === 'strict') return mode || 'shortest'; + throw new $TypeError('Incorrect `mode` option'); +}; + + +/***/ }), +/* 654 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var anObject = __webpack_require__(46); +var createIteratorProxy = __webpack_require__(263); +var iteratorCloseAll = __webpack_require__(264); + +var $TypeError = TypeError; +var slice = uncurryThis([].slice); +var push = uncurryThis([].push); +var ITERATOR_IS_EXHAUSTED = 'Iterator is exhausted'; +var THROW = 'throw'; + +// eslint-disable-next-line max-statements -- specification case +var IteratorProxy = createIteratorProxy(function () { + var iterCount = this.iterCount; + if (!iterCount) { + this.done = true; + return; + } + var openIters = this.openIters; + var iters = this.iters; + var padding = this.padding; + var mode = this.mode; + var finishResults = this.finishResults; + + var results = []; + var result, done; + for (var i = 0; i < iterCount; i++) { + var iter = iters[i]; + if (iter === null) { + result = padding[i]; + } else { + try { + result = anObject(call(iter.next, iter.iterator)); + done = result.done; + result = result.value; + } catch (error) { + openIters[i] = undefined; + return iteratorCloseAll(openIters, THROW, error); + } + if (done) { + openIters[i] = undefined; + this.openItersCount--; + if (mode === 'shortest') { + this.done = true; + return iteratorCloseAll(openIters, 'normal', undefined); + } + if (mode === 'strict') { + if (i) { + return iteratorCloseAll(openIters, THROW, new $TypeError(ITERATOR_IS_EXHAUSTED)); + } + + var open, openDone; + for (var k = 1; k < iterCount; k++) { + // eslint-disable-next-line max-depth -- specification case + try { + open = anObject(call(iters[k].next, iters[k].iterator)); + openDone = open.done; + open = open.value; + } catch (error) { + openIters[k] = undefined; + return iteratorCloseAll(openIters, THROW, error); + } + // eslint-disable-next-line max-depth -- specification case + if (openDone) { + openIters[k] = undefined; + this.openItersCount--; + } else { + return iteratorCloseAll(openIters, THROW, new $TypeError(ITERATOR_IS_EXHAUSTED)); + } + } + this.done = true; + return; + } + if (!this.openItersCount) { + this.done = true; + return; + } + iters[i] = null; + result = padding[i]; + } + } + push(results, result); + } + + return finishResults ? finishResults(results) : results; +}); + +module.exports = function (iters, mode, padding, finishResults) { + var iterCount = iters.length; + return new IteratorProxy({ + iters: iters, + iterCount: iterCount, + openIters: slice(iters, 0), + openItersCount: iterCount, + mode: mode, + padding: padding, + finishResults: finishResults + }); +}; + + +/***/ }), +/* 655 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var anObjectOrUndefined = __webpack_require__(574); +var createProperty = __webpack_require__(90); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var getBuiltIn = __webpack_require__(23); +var propertyIsEnumerableModule = __webpack_require__(10); +var getIteratorFlattenable = __webpack_require__(276); +var getModeOption = __webpack_require__(653); +var iteratorCloseAll = __webpack_require__(264); +var iteratorZip = __webpack_require__(654); +var IS_PURE = __webpack_require__(36); + +var create = getBuiltIn('Object', 'create'); +var ownKeys = getBuiltIn('Reflect', 'ownKeys'); +var push = uncurryThis([].push); +var THROW = 'throw'; + +// `Iterator.zipKeyed` method +// https://github.com/tc39/proposal-joint-iteration +$({ target: 'Iterator', stat: true, forced: IS_PURE }, { + zipKeyed: function zipKeyed(iterables /* , options */) { + anObject(iterables); + var options = arguments.length > 1 ? anObjectOrUndefined(arguments[1]) : undefined; + var mode = getModeOption(options); + var paddingOption = mode === 'longest' ? anObjectOrUndefined(options && options.padding) : undefined; + + var iters = []; + var padding = []; + var allKeys = ownKeys(iterables); + var keys = []; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + var i, key, value; + for (i = 0; i < allKeys.length; i++) try { + key = allKeys[i]; + if (!call(propertyIsEnumerable, iterables, key)) continue; + value = iterables[key]; + if (value !== undefined) { + push(keys, key); + push(iters, getIteratorFlattenable(value, false)); + } + } catch (error) { + return iteratorCloseAll(iters, THROW, error); + } + + var iterCount = iters.length; + if (mode === 'longest') { + if (paddingOption === undefined) { + for (i = 0; i < iterCount; i++) push(padding, undefined); + } else { + for (i = 0; i < keys.length; i++) { + try { + value = paddingOption[keys[i]]; + } catch (error) { + return iteratorCloseAll(iters, THROW, error); + } + push(padding, value); + } + } + } + + return iteratorZip(iters, mode, padding, function (results) { + var obj = create(null); + for (var j = 0; j < iterCount; j++) { + createProperty(obj, keys[j], results[j]); + } + return obj; + }); + } +}); + + +/***/ }), +/* 656 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aMap = __webpack_require__(657); +var remove = __webpack_require__(297).remove; + +// `Map.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + deleteAll: function deleteAll(/* ...elements */) { + var collection = aMap(this); + var allDeleted = true; + var wasDeleted; + for (var k = 0, len = arguments.length; k < len; k++) { + wasDeleted = remove(collection, arguments[k]); + allDeleted = allDeleted && wasDeleted; + } return !!allDeleted; + } +}); + + +/***/ }), +/* 657 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var has = __webpack_require__(297).has; + +// Perform ? RequireInternalSlot(M, [[MapData]]) +module.exports = function (it) { + has(it); + return it; +}; + + +/***/ }), +/* 658 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aMap = __webpack_require__(657); +var MapHelpers = __webpack_require__(297); + +var get = MapHelpers.get; +var has = MapHelpers.has; +var set = MapHelpers.set; + +// `Map.prototype.emplace` method +// https://github.com/tc39/proposal-upsert +$({ target: 'Map', proto: true, real: true, forced: true }, { + emplace: function emplace(key, handler) { + var map = aMap(this); + var value, inserted; + if (has(map, key)) { + value = get(map, key); + if ('update' in handler) { + value = handler.update(value, key, map); + set(map, key, value); + } return value; + } + inserted = handler.insert(key, map); + set(map, key, inserted); + return inserted; + } +}); + + +/***/ }), +/* 659 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +// `Map.prototype.every` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + every: function every(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return iterate(map, function (value, key) { + if (!boundFunction(value, key, map)) return false; + }, true) !== false; + } +}); + + +/***/ }), +/* 660 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var MapHelpers = __webpack_require__(297); +var iterate = __webpack_require__(608); + +var Map = MapHelpers.Map; +var set = MapHelpers.set; + +// `Map.prototype.filter` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + filter: function filter(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var newMap = new Map(); + iterate(map, function (value, key) { + if (boundFunction(value, key, map)) set(newMap, key, value); + }); + return newMap; + } +}); + + +/***/ }), +/* 661 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +// `Map.prototype.find` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + find: function find(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var result = iterate(map, function (value, key) { + if (boundFunction(value, key, map)) return { value: value }; + }, true); + return result && result.value; + } +}); + + +/***/ }), +/* 662 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +// `Map.prototype.findKey` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + findKey: function findKey(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var result = iterate(map, function (value, key) { + if (boundFunction(value, key, map)) return { key: key }; + }, true); + return result && result.key; + } +}); + + +/***/ }), +/* 663 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var MapHelpers = __webpack_require__(297); +var createCollectionFrom = __webpack_require__(664); + +// `Map.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from +$({ target: 'Map', stat: true, forced: true }, { + from: createCollectionFrom(MapHelpers.Map, MapHelpers.set, true) +}); + + +/***/ }), +/* 664 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://tc39.github.io/proposal-setmap-offrom/ +var bind = __webpack_require__(84); +var anObject = __webpack_require__(46); +var toObject = __webpack_require__(39); +var iterate = __webpack_require__(136); + +module.exports = function (C, adder, ENTRY) { + return function from(source /* , mapFn, thisArg */) { + var O = toObject(source); + var length = arguments.length; + var mapFn = length > 1 ? arguments[1] : undefined; + var mapping = mapFn !== undefined; + var boundFunction = mapping ? bind(mapFn, length > 2 ? arguments[2] : undefined) : undefined; + var result = new C(); + var n = 0; + iterate(O, function (nextItem) { + var entry = mapping ? boundFunction(nextItem, n++) : nextItem; + if (ENTRY) adder(result, anObject(entry)[0], entry[1]); + else adder(result, entry); + }); + return result; + }; +}; + + +/***/ }), +/* 665 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var sameValueZero = __webpack_require__(666); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +// `Map.prototype.includes` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + includes: function includes(searchElement) { + return iterate(aMap(this), function (value) { + if (sameValueZero(value, searchElement)) return true; + }, true) === true; + } +}); + + +/***/ }), +/* 666 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// `SameValueZero` abstract operation +// https://tc39.es/ecma262/#sec-samevaluezero +module.exports = function (x, y) { + // eslint-disable-next-line no-self-compare -- NaN check + return x === y || x !== x && y !== y; +}; + + +/***/ }), +/* 667 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var iterate = __webpack_require__(136); +var isCallable = __webpack_require__(21); +var aCallable = __webpack_require__(30); +var Map = __webpack_require__(297).Map; + +// `Map.keyBy` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', stat: true, forced: true }, { + keyBy: function keyBy(iterable, keyDerivative) { + var C = isCallable(this) ? this : Map; + var newMap = new C(); + aCallable(keyDerivative); + var setter = aCallable(newMap.set); + iterate(iterable, function (element) { + call(setter, newMap, keyDerivative(element), element); + }); + return newMap; + } +}); + + +/***/ }), +/* 668 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +// `Map.prototype.keyOf` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + keyOf: function keyOf(searchElement) { + var result = iterate(aMap(this), function (value, key) { + if (value === searchElement) return { key: key }; + }, true); + return result && result.key; + } +}); + + +/***/ }), +/* 669 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var MapHelpers = __webpack_require__(297); +var iterate = __webpack_require__(608); + +var Map = MapHelpers.Map; +var set = MapHelpers.set; + +// `Map.prototype.mapKeys` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + mapKeys: function mapKeys(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var newMap = new Map(); + iterate(map, function (value, key) { + set(newMap, boundFunction(value, key, map), value); + }); + return newMap; + } +}); + + +/***/ }), +/* 670 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var MapHelpers = __webpack_require__(297); +var iterate = __webpack_require__(608); + +var Map = MapHelpers.Map; +var set = MapHelpers.set; + +// `Map.prototype.mapValues` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + mapValues: function mapValues(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var newMap = new Map(); + iterate(map, function (value, key) { + set(newMap, key, boundFunction(value, key, map)); + }); + return newMap; + } +}); + + +/***/ }), +/* 671 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(136); +var set = __webpack_require__(297).set; + +// `Map.prototype.merge` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, arity: 1, forced: true }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + merge: function merge(iterable /* ...iterables */) { + var map = aMap(this); + var argumentsLength = arguments.length; + var i = 0; + while (i < argumentsLength) { + iterate(arguments[i++], function (key, value) { + set(map, key, value); + }, { AS_ENTRIES: true }); + } + return map; + } +}); + + +/***/ }), +/* 672 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var MapHelpers = __webpack_require__(297); +var createCollectionOf = __webpack_require__(673); + +// `Map.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of +$({ target: 'Map', stat: true, forced: true }, { + of: createCollectionOf(MapHelpers.Map, MapHelpers.set, true) +}); + + +/***/ }), +/* 673 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var anObject = __webpack_require__(46); + +// https://tc39.github.io/proposal-setmap-offrom/ +module.exports = function (C, adder, ENTRY) { + return function of() { + var result = new C(); + var length = arguments.length; + for (var index = 0; index < length; index++) { + var entry = arguments[index]; + if (ENTRY) adder(result, anObject(entry)[0], entry[1]); + else adder(result, entry); + } return result; + }; +}; + + +/***/ }), +/* 674 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aCallable = __webpack_require__(30); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +var $TypeError = TypeError; + +// `Map.prototype.reduce` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + reduce: function reduce(callbackfn /* , initialValue */) { + var map = aMap(this); + var noInitial = arguments.length < 2; + var accumulator = noInitial ? undefined : arguments[1]; + aCallable(callbackfn); + iterate(map, function (value, key) { + if (noInitial) { + noInitial = false; + accumulator = value; + } else { + accumulator = callbackfn(accumulator, value, key, map); + } + }); + if (noInitial) throw new $TypeError('Reduce of empty map with no initial value'); + return accumulator; + } +}); + + +/***/ }), +/* 675 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aMap = __webpack_require__(657); +var iterate = __webpack_require__(608); + +// `Map.prototype.some` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + some: function some(callbackfn /* , thisArg */) { + var map = aMap(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return iterate(map, function (value, key) { + if (boundFunction(value, key, map)) return true; + }, true) === true; + } +}); + + +/***/ }), +/* 676 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aCallable = __webpack_require__(30); +var aMap = __webpack_require__(657); +var MapHelpers = __webpack_require__(297); + +var $TypeError = TypeError; +var get = MapHelpers.get; +var has = MapHelpers.has; +var set = MapHelpers.set; + +// `Map.prototype.update` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Map', proto: true, real: true, forced: true }, { + update: function update(key, callback /* , thunk */) { + var map = aMap(this); + var length = arguments.length; + aCallable(callback); + var isPresentInMap = has(map, key); + if (!isPresentInMap && length < 3) { + throw new $TypeError('Updating absent value'); + } + var value = isPresentInMap ? get(map, key) : aCallable(length > 2 ? arguments[2] : undefined)(key, map); + set(map, key, callback(value, key, map)); + return map; + } +}); + + +/***/ }), +/* 677 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: remove from `core-js@4` +var $ = __webpack_require__(3); +var upsert = __webpack_require__(678); + +// `Map.prototype.updateOrInsert` method (replaced by `Map.prototype.emplace`) +// https://github.com/thumbsupep/proposal-upsert +$({ target: 'Map', proto: true, real: true, name: 'upsert', forced: true }, { + updateOrInsert: upsert +}); + + +/***/ }), +/* 678 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8); +var aCallable = __webpack_require__(30); +var isCallable = __webpack_require__(21); +var anObject = __webpack_require__(46); + +var $TypeError = TypeError; + +// `Map.prototype.upsert` method +// https://github.com/tc39/proposal-upsert +module.exports = function upsert(key, updateFn /* , insertFn */) { + var map = anObject(this); + var get = aCallable(map.get); + var has = aCallable(map.has); + var set = aCallable(map.set); + var insertFn = arguments.length > 2 ? arguments[2] : undefined; + var value; + if (!isCallable(updateFn) && !isCallable(insertFn)) { + throw new $TypeError('At least one callback required'); + } + if (call(has, map, key)) { + value = call(get, map, key); + if (isCallable(updateFn)) { + value = updateFn(value); + call(set, map, key, value); + } + } else if (isCallable(insertFn)) { + value = insertFn(); + call(set, map, key, value); + } return value; +}; + + +/***/ }), +/* 679 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: remove from `core-js@4` +var $ = __webpack_require__(3); +var upsert = __webpack_require__(678); + +// `Map.prototype.upsert` method (replaced by `Map.prototype.emplace`) +// https://github.com/thumbsupep/proposal-upsert +$({ target: 'Map', proto: true, real: true, forced: true }, { + upsert: upsert +}); + + +/***/ }), +/* 680 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var clamp = __webpack_require__(681); + +// TODO: Remove from `core-js@4` +// `Math.clamp` method +// https://github.com/tc39/proposal-math-clamp +$({ target: 'Math', stat: true, forced: true }, { + clamp: clamp +}); + + +/***/ }), +/* 681 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var aNumber = __webpack_require__(682); + +var $min = Math.min; +var $max = Math.max; + +module.exports = function clamp(value, min, max) { + return $min($max(aNumber(value), aNumber(min)), aNumber(max)); +}; + + +/***/ }), +/* 682 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $TypeError = TypeError; + +module.exports = function (argument) { + if (typeof argument == 'number') return argument; + throw new $TypeError('Argument is not a number'); +}; + + +/***/ }), +/* 683 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.DEG_PER_RAD` constant +// https://rwaldron.github.io/proposal-math-extensions/ +$({ target: 'Math', stat: true, nonConfigurable: true, nonWritable: true }, { + DEG_PER_RAD: Math.PI / 180 +}); + + +/***/ }), +/* 684 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +var RAD_PER_DEG = 180 / Math.PI; + +// `Math.degrees` method +// https://rwaldron.github.io/proposal-math-extensions/ +$({ target: 'Math', stat: true, forced: true }, { + degrees: function degrees(radians) { + return radians * RAD_PER_DEG; + } +}); + + +/***/ }), +/* 685 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +var scale = __webpack_require__(686); +var fround = __webpack_require__(217); + +// `Math.fscale` method +// https://rwaldron.github.io/proposal-math-extensions/ +$({ target: 'Math', stat: true, forced: true }, { + fscale: function fscale(x, inLow, inHigh, outLow, outHigh) { + return fround(scale(x, inLow, inHigh, outLow, outHigh)); + } +}); + + +/***/ }), +/* 686 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// `Math.scale` method implementation +// https://rwaldron.github.io/proposal-math-extensions/ +module.exports = function scale(x, inLow, inHigh, outLow, outHigh) { + var nx = +x; + var nInLow = +inLow; + var nInHigh = +inHigh; + var nOutLow = +outLow; + var nOutHigh = +outHigh; + // eslint-disable-next-line no-self-compare -- NaN check + if (nx !== nx || nInLow !== nInLow || nInHigh !== nInHigh || nOutLow !== nOutLow || nOutHigh !== nOutHigh) return NaN; + if (nx === Infinity || nx === -Infinity) return nx; + return (nx - nInLow) * (nOutHigh - nOutLow) / (nInHigh - nInLow) + nOutLow; +}; + + +/***/ }), +/* 687 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.iaddh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +// TODO: Remove from `core-js@4` +$({ target: 'Math', stat: true, forced: true }, { + iaddh: function iaddh(x0, x1, y0, y1) { + var $x0 = x0 >>> 0; + var $x1 = x1 >>> 0; + var $y0 = y0 >>> 0; + return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0; + } +}); + + +/***/ }), +/* 688 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.imulh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +// TODO: Remove from `core-js@4` +$({ target: 'Math', stat: true, forced: true }, { + imulh: function imulh(u, v) { + var UINT16 = 0xFFFF; + var $u = +u; + var $v = +v; + var u0 = $u & UINT16; + var v0 = $v & UINT16; + var u1 = $u >> 16; + var v1 = $v >> 16; + var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); + return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16); + } +}); + + +/***/ }), +/* 689 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.isubh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +// TODO: Remove from `core-js@4` +$({ target: 'Math', stat: true, forced: true }, { + isubh: function isubh(x0, x1, y0, y1) { + var $x0 = x0 >>> 0; + var $x1 = x1 >>> 0; + var $y0 = y0 >>> 0; + return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0; + } +}); + + +/***/ }), +/* 690 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.RAD_PER_DEG` constant +// https://rwaldron.github.io/proposal-math-extensions/ +$({ target: 'Math', stat: true, nonConfigurable: true, nonWritable: true }, { + RAD_PER_DEG: 180 / Math.PI +}); + + +/***/ }), +/* 691 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +var DEG_PER_RAD = Math.PI / 180; + +// `Math.radians` method +// https://rwaldron.github.io/proposal-math-extensions/ +$({ target: 'Math', stat: true, forced: true }, { + radians: function radians(degrees) { + return degrees * DEG_PER_RAD; + } +}); + + +/***/ }), +/* 692 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var scale = __webpack_require__(686); + +// `Math.scale` method +// https://rwaldron.github.io/proposal-math-extensions/ +$({ target: 'Math', stat: true, forced: true }, { + scale: scale +}); + + +/***/ }), +/* 693 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var anObject = __webpack_require__(46); +var numberIsFinite = __webpack_require__(329); +var createIteratorConstructor = __webpack_require__(177); +var createIterResultObject = __webpack_require__(179); +var InternalStateModule = __webpack_require__(51); + +var SEEDED_RANDOM = 'Seeded Random'; +var SEEDED_RANDOM_GENERATOR = SEEDED_RANDOM + ' Generator'; +var SEED_TYPE_ERROR = 'Math.seededPRNG() argument should have a "seed" field with a finite value.'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(SEEDED_RANDOM_GENERATOR); +var $TypeError = TypeError; + +var $SeededRandomGenerator = createIteratorConstructor(function SeededRandomGenerator(seed) { + setInternalState(this, { + type: SEEDED_RANDOM_GENERATOR, + seed: seed % 2147483647 + }); +}, SEEDED_RANDOM, function next() { + var state = getInternalState(this); + var seed = state.seed = (state.seed * 1103515245 + 12345) % 2147483647; + return createIterResultObject((seed & 1073741823) / 1073741823, false); +}); + +// `Math.seededPRNG` method +// https://github.com/tc39/proposal-seeded-random +// based on https://github.com/tc39/proposal-seeded-random/blob/78b8258835b57fc2100d076151ab506bc3202ae6/demo.html +$({ target: 'Math', stat: true, forced: true }, { + seededPRNG: function seededPRNG(it) { + var seed = anObject(it).seed; + if (!numberIsFinite(seed)) throw new $TypeError(SEED_TYPE_ERROR); + return new $SeededRandomGenerator(seed); + } +}); + + +/***/ }), +/* 694 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.signbit` method +// https://github.com/tc39/proposal-Math.signbit +$({ target: 'Math', stat: true, forced: true }, { + signbit: function signbit(x) { + var n = +x; + // eslint-disable-next-line no-self-compare -- NaN check + return n === n && n === 0 ? 1 / n === -Infinity : n < 0; + } +}); + + +/***/ }), +/* 695 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); + +// `Math.umulh` method +// https://gist.github.com/BrendanEich/4294d5c212a6d2254703 +// TODO: Remove from `core-js@4` +$({ target: 'Math', stat: true, forced: true }, { + umulh: function umulh(u, v) { + var UINT16 = 0xFFFF; + var $u = +u; + var $v = +v; + var u0 = $u & UINT16; + var v0 = $v & UINT16; + var u1 = $u >>> 16; + var v1 = $v >>> 16; + var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16); + return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16); + } +}); + + +/***/ }), +/* 696 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var $clamp = __webpack_require__(681); +var thisNumberValue = __webpack_require__(324); + +// `Number.prototype.clamp` method +// https://github.com/tc39/proposal-math-clamp +$({ target: 'Number', proto: true, forced: true }, { + clamp: function clamp(min, max) { + return $clamp(thisNumberValue(this), min, max); + } +}); + + +/***/ }), +/* 697 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var toIntegerOrInfinity = __webpack_require__(61); + +var INVALID_NUMBER_REPRESENTATION = 'Invalid number representation'; +var INVALID_RADIX = 'Invalid radix'; +var $RangeError = RangeError; +var $SyntaxError = SyntaxError; +var $TypeError = TypeError; +var $parseInt = parseInt; +var pow = Math.pow; +var valid = /^[0-9a-z]+(\.[0-9a-z]+)?$/; +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var exec = uncurryThis(valid.exec); +var numberToString = uncurryThis(1.1.toString); +var stringSlice = uncurryThis(''.slice); +var split = uncurryThis(''.split); + +var validDigitForRadix = function (string, R) { + for (var i = 0; i < string.length; i++) { + var code = charCodeAt(string, i); + // '.' is allowed + if (code === 0x2E) continue; + // '0'-'9' - digit value 0-9 + if (code >= 0x30 && code <= 0x39) { + if (code - 0x30 >= R) return false; + // 'a'-'z' - digit value 10-35 + } else if (code >= 0x61 && code <= 0x7A) { + if (code - 0x61 + 10 >= R) return false; + } else return false; + } + return true; +}; + +// `Number.fromString` method +// https://github.com/tc39/proposal-number-fromstring +$({ target: 'Number', stat: true, forced: true }, { + fromString: function fromString(string, radix) { + var sign = 1; + if (typeof string != 'string') throw new $TypeError(INVALID_NUMBER_REPRESENTATION); + if (!string.length) throw new $SyntaxError(INVALID_NUMBER_REPRESENTATION); + if (charAt(string, 0) === '-') { + sign = -1; + string = stringSlice(string, 1); + if (!string.length) throw new $SyntaxError(INVALID_NUMBER_REPRESENTATION); + } + var R = radix === undefined ? 10 : toIntegerOrInfinity(radix); + if (R < 2 || R > 36) throw new $RangeError(INVALID_RADIX); + if (!exec(valid, string) || !validDigitForRadix(string, R)) throw new $SyntaxError(INVALID_NUMBER_REPRESENTATION); + var parts = split(string, '.'); + var mathNum = $parseInt(parts[0], R); + if (parts.length > 1) mathNum += $parseInt(parts[1], R) / pow(R, parts[1].length); + if (R === 10) { + var compareString = string; + if (parts.length > 1) { + var fraction = parts[1]; + while (fraction.length && charAt(fraction, fraction.length - 1) === '0') { + fraction = stringSlice(fraction, 0, -1); + } + compareString = fraction.length ? parts[0] + '.' + fraction : parts[0]; + } + if (numberToString(mathNum, R) !== compareString) throw new $SyntaxError(INVALID_NUMBER_REPRESENTATION); + } + return sign * mathNum; + } +}); + + +/***/ }), +/* 698 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var NumericRangeIterator = __webpack_require__(630); + +// `Number.range` method +// https://github.com/tc39/proposal-iterator.range +// TODO: Remove from `core-js@4` +$({ target: 'Number', stat: true, forced: true }, { + range: function range(start, end, option) { + return new NumericRangeIterator(start, end, option, 'number', 0, 1); + } +}); + + +/***/ }), +/* 699 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ObjectIterator = __webpack_require__(700); + +// `Object.iterateEntries` method +// https://github.com/tc39/proposal-object-iteration +$({ target: 'Object', stat: true, forced: true }, { + iterateEntries: function iterateEntries(object) { + return new ObjectIterator(object, 'entries'); + } +}); + + +/***/ }), +/* 700 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var InternalStateModule = __webpack_require__(51); +var createIteratorConstructor = __webpack_require__(177); +var createIterResultObject = __webpack_require__(179); +var hasOwn = __webpack_require__(38); +var objectKeys = __webpack_require__(73); +var toObject = __webpack_require__(39); + +var OBJECT_ITERATOR = 'Object Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(OBJECT_ITERATOR); + +module.exports = createIteratorConstructor(function ObjectIterator(source, mode) { + var object = toObject(source); + setInternalState(this, { + type: OBJECT_ITERATOR, + mode: mode, + object: object, + keys: objectKeys(object), + index: 0 + }); +}, 'Object', function next() { + var state = getInternalState(this); + var keys = state.keys; + while (true) { + if (keys === null || state.index >= keys.length) { + state.object = state.keys = null; + return createIterResultObject(undefined, true); + } + var key = keys[state.index++]; + var object = state.object; + if (!hasOwn(object, key)) continue; + switch (state.mode) { + case 'keys': return createIterResultObject(key, false); + case 'values': return createIterResultObject(object[key], false); + } /* entries */ return createIterResultObject([key, object[key]], false); + } +}); + + +/***/ }), +/* 701 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ObjectIterator = __webpack_require__(700); + +// `Object.iterateKeys` method +// https://github.com/tc39/proposal-object-iteration +$({ target: 'Object', stat: true, forced: true }, { + iterateKeys: function iterateKeys(object) { + return new ObjectIterator(object, 'keys'); + } +}); + + +/***/ }), +/* 702 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ObjectIterator = __webpack_require__(700); + +// `Object.iterateValues` method +// https://github.com/tc39/proposal-object-iteration +$({ target: 'Object', stat: true, forced: true }, { + iterateValues: function iterateValues(object) { + return new ObjectIterator(object, 'values'); + } +}); + + +/***/ }), +/* 703 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's split to modules listed below +__webpack_require__(704); +__webpack_require__(705); +__webpack_require__(706); + + +/***/ }), +/* 704 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// https://github.com/tc39/proposal-observable +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var DESCRIPTORS = __webpack_require__(6); +var setSpecies = __webpack_require__(200); +var aCallable = __webpack_require__(30); +var anObject = __webpack_require__(46); +var anInstance = __webpack_require__(215); +var isCallable = __webpack_require__(21); +var isNullOrUndefined = __webpack_require__(17); +var isObject = __webpack_require__(20); +var getMethod = __webpack_require__(29); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltIns = __webpack_require__(214); +var defineBuiltInAccessor = __webpack_require__(77); +var hostReportErrors = __webpack_require__(390); +var wellKnownSymbol = __webpack_require__(33); +var InternalStateModule = __webpack_require__(51); + +var $$OBSERVABLE = wellKnownSymbol('observable'); +var OBSERVABLE = 'Observable'; +var SUBSCRIPTION = 'Subscription'; +var SUBSCRIPTION_OBSERVER = 'SubscriptionObserver'; +var getterFor = InternalStateModule.getterFor; +var setInternalState = InternalStateModule.set; +var getObservableInternalState = getterFor(OBSERVABLE); +var getSubscriptionInternalState = getterFor(SUBSCRIPTION); +var getSubscriptionObserverInternalState = getterFor(SUBSCRIPTION_OBSERVER); + +var SubscriptionState = function (observer) { + this.observer = anObject(observer); + this.cleanup = null; + this.subscriptionObserver = null; +}; + +SubscriptionState.prototype = { + type: SUBSCRIPTION, + clean: function () { + var cleanup = this.cleanup; + if (cleanup) { + this.cleanup = null; + try { + cleanup(); + } catch (error) { + hostReportErrors(error); + } + } + }, + close: function () { + if (!DESCRIPTORS) { + var subscription = this.facade; + var subscriptionObserver = this.subscriptionObserver; + subscription.closed = true; + if (subscriptionObserver) subscriptionObserver.closed = true; + } this.observer = null; + }, + isClosed: function () { + return this.observer === null; + } +}; + +var Subscription = function (observer, subscriber) { + var subscriptionState = setInternalState(this, new SubscriptionState(observer)); + var start; + if (!DESCRIPTORS) this.closed = false; + try { + if (start = getMethod(observer, 'start')) call(start, observer, this); + } catch (error) { + hostReportErrors(error); + } + if (subscriptionState.isClosed()) return; + var subscriptionObserver = subscriptionState.subscriptionObserver = new SubscriptionObserver(subscriptionState); + try { + var cleanup = subscriber(subscriptionObserver); + var subscription = cleanup; + if (!isNullOrUndefined(cleanup)) subscriptionState.cleanup = isCallable(cleanup.unsubscribe) + ? function () { subscription.unsubscribe(); } + : aCallable(cleanup); + } catch (error) { + subscriptionObserver.error(error); + return; + } if (subscriptionState.isClosed()) subscriptionState.clean(); +}; + +Subscription.prototype = defineBuiltIns({}, { + unsubscribe: function unsubscribe() { + var subscriptionState = getSubscriptionInternalState(this); + if (!subscriptionState.isClosed()) { + subscriptionState.close(); + subscriptionState.clean(); + } + } +}); + +if (DESCRIPTORS) defineBuiltInAccessor(Subscription.prototype, 'closed', { + configurable: true, + get: function closed() { + return getSubscriptionInternalState(this).isClosed(); + } +}); + +var SubscriptionObserver = function (subscriptionState) { + setInternalState(this, { + type: SUBSCRIPTION_OBSERVER, + subscriptionState: subscriptionState + }); + if (!DESCRIPTORS) this.closed = false; +}; + +SubscriptionObserver.prototype = defineBuiltIns({}, { + next: function next(value) { + var subscriptionState = getSubscriptionObserverInternalState(this).subscriptionState; + if (!subscriptionState.isClosed()) { + var observer = subscriptionState.observer; + try { + var nextMethod = getMethod(observer, 'next'); + if (nextMethod) call(nextMethod, observer, value); + } catch (error) { + hostReportErrors(error); + } + } + }, + error: function error(value) { + var subscriptionState = getSubscriptionObserverInternalState(this).subscriptionState; + if (!subscriptionState.isClosed()) { + var observer = subscriptionState.observer; + subscriptionState.close(); + try { + var errorMethod = getMethod(observer, 'error'); + if (errorMethod) call(errorMethod, observer, value); + else hostReportErrors(value); + } catch (err) { + hostReportErrors(err); + } subscriptionState.clean(); + } + }, + complete: function complete() { + var subscriptionState = getSubscriptionObserverInternalState(this).subscriptionState; + if (!subscriptionState.isClosed()) { + var observer = subscriptionState.observer; + subscriptionState.close(); + try { + var completeMethod = getMethod(observer, 'complete'); + if (completeMethod) call(completeMethod, observer); + } catch (error) { + hostReportErrors(error); + } subscriptionState.clean(); + } + } +}); + +if (DESCRIPTORS) defineBuiltInAccessor(SubscriptionObserver.prototype, 'closed', { + configurable: true, + get: function closed() { + return getSubscriptionObserverInternalState(this).subscriptionState.isClosed(); + } +}); + +var $Observable = function Observable(subscriber) { + anInstance(this, ObservablePrototype); + setInternalState(this, { + type: OBSERVABLE, + subscriber: aCallable(subscriber) + }); +}; + +var ObservablePrototype = $Observable.prototype; + +defineBuiltIns(ObservablePrototype, { + subscribe: function subscribe(observer) { + var length = arguments.length; + return new Subscription(isCallable(observer) ? { + next: observer, + error: length > 1 ? arguments[1] : undefined, + complete: length > 2 ? arguments[2] : undefined + } : isObject(observer) ? observer : {}, getObservableInternalState(this).subscriber); + } +}); + +defineBuiltIn(ObservablePrototype, $$OBSERVABLE, function () { return this; }); + +$({ global: true, constructor: true, forced: true }, { + Observable: $Observable +}); + +setSpecies(OBSERVABLE); + + +/***/ }), +/* 705 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var call = __webpack_require__(8); +var anObject = __webpack_require__(46); +var isConstructor = __webpack_require__(89); +var getIterator = __webpack_require__(139); +var getIteratorMethod = __webpack_require__(140); +var getMethod = __webpack_require__(29); +var iterate = __webpack_require__(136); +var wellKnownSymbol = __webpack_require__(33); + +var $$OBSERVABLE = wellKnownSymbol('observable'); + +// `Observable.from` method +// https://github.com/tc39/proposal-observable +$({ target: 'Observable', stat: true, forced: true }, { + from: function from(x) { + var C = isConstructor(this) ? this : getBuiltIn('Observable'); + var observableMethod = getMethod(anObject(x), $$OBSERVABLE); + if (observableMethod) { + var observable = anObject(call(observableMethod, x)); + return observable.constructor === C ? observable : new C(function (observer) { + return observable.subscribe(observer); + }); + } + var iteratorMethod = getIteratorMethod(x); + // validate that x is iterable synchronously during `from()` call + if (!iteratorMethod) getIterator(x); + return new C(function (observer) { + iterate(getIterator(x, iteratorMethod), function (it, stop) { + observer.next(it); + if (observer.closed) return stop(); + }, { IS_ITERATOR: true, INTERRUPTED: true }); + observer.complete(); + }); + } +}); + + +/***/ }), +/* 706 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var isConstructor = __webpack_require__(89); + +var Array = getBuiltIn('Array'); + +// `Observable.of` method +// https://github.com/tc39/proposal-observable +$({ target: 'Observable', stat: true, forced: true }, { + of: function of() { + var C = isConstructor(this) ? this : getBuiltIn('Observable'); + var length = arguments.length; + var items = Array(length); + var index = 0; + while (index < length) items[index] = arguments[index++]; + return new C(function (observer) { + for (var i = 0; i < length; i++) { + observer.next(items[i]); + if (observer.closed) return; + } observer.complete(); + }); + } +}); + + +/***/ }), +/* 707 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); + +var toMetadataKey = ReflectMetadataModule.toKey; +var ordinaryDefineOwnMetadata = ReflectMetadataModule.set; + +// `Reflect.defineMetadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + defineMetadata: function defineMetadata(metadataKey, metadataValue, target /* , targetKey */) { + var targetKey = arguments.length < 4 ? undefined : toMetadataKey(arguments[3]); + ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), targetKey); + } +}); + + +/***/ }), +/* 708 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` +__webpack_require__(289); +__webpack_require__(585); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var shared = __webpack_require__(34); + +var Map = getBuiltIn('Map'); +var WeakMap = getBuiltIn('WeakMap'); +var push = uncurryThis([].push); + +var metadata = shared('metadata'); +var store = metadata.store || (metadata.store = new WeakMap()); + +var getOrCreateMetadataMap = function (target, targetKey, create) { + var targetMetadata = store.get(target); + if (!targetMetadata) { + if (!create) return; + store.set(target, targetMetadata = new Map()); + } + var keyMetadata = targetMetadata.get(targetKey); + if (!keyMetadata) { + if (!create) return; + targetMetadata.set(targetKey, keyMetadata = new Map()); + } return keyMetadata; +}; + +var ordinaryHasOwnMetadata = function (MetadataKey, O, P) { + var metadataMap = getOrCreateMetadataMap(O, P, false); + return metadataMap === undefined ? false : metadataMap.has(MetadataKey); +}; + +var ordinaryGetOwnMetadata = function (MetadataKey, O, P) { + var metadataMap = getOrCreateMetadataMap(O, P, false); + return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey); +}; + +var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) { + getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue); +}; + +var ordinaryOwnMetadataKeys = function (target, targetKey) { + var metadataMap = getOrCreateMetadataMap(target, targetKey, false); + var keys = []; + if (metadataMap) metadataMap.forEach(function (_, key) { push(keys, key); }); + return keys; +}; + +var toMetadataKey = function (it) { + return it === undefined || typeof it == 'symbol' ? it : String(it); +}; + +module.exports = { + store: store, + getMap: getOrCreateMetadataMap, + has: ordinaryHasOwnMetadata, + get: ordinaryGetOwnMetadata, + set: ordinaryDefineOwnMetadata, + keys: ordinaryOwnMetadataKeys, + toKey: toMetadataKey +}; + + +/***/ }), +/* 709 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); + +var toMetadataKey = ReflectMetadataModule.toKey; +var getOrCreateMetadataMap = ReflectMetadataModule.getMap; +var store = ReflectMetadataModule.store; + +// `Reflect.deleteMetadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); + var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false); + if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false; + if (metadataMap.size) return true; + var targetMetadata = store.get(target); + targetMetadata['delete'](targetKey); + return !!targetMetadata.size || store['delete'](target); + } +}); + + +/***/ }), +/* 710 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); +var getPrototypeOf = __webpack_require__(134); + +var ordinaryHasOwnMetadata = ReflectMetadataModule.has; +var ordinaryGetOwnMetadata = ReflectMetadataModule.get; +var toMetadataKey = ReflectMetadataModule.toKey; + +var ordinaryGetMetadata = function (MetadataKey, O, P) { + var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P); + var parent = getPrototypeOf(O); + return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined; +}; + +// `Reflect.getMetadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + getMetadata: function getMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); + return ordinaryGetMetadata(metadataKey, anObject(target), targetKey); + } +}); + + +/***/ }), +/* 711 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); +var getPrototypeOf = __webpack_require__(134); +var $arrayUniqueBy = __webpack_require__(607); + +var arrayUniqueBy = uncurryThis($arrayUniqueBy); +var concat = uncurryThis([].concat); +var ordinaryOwnMetadataKeys = ReflectMetadataModule.keys; +var toMetadataKey = ReflectMetadataModule.toKey; + +var ordinaryMetadataKeys = function (O, P) { + var oKeys = ordinaryOwnMetadataKeys(O, P); + var parent = getPrototypeOf(O); + if (parent === null) return oKeys; + var pKeys = ordinaryMetadataKeys(parent, P); + return pKeys.length ? oKeys.length ? arrayUniqueBy(concat(oKeys, pKeys)) : pKeys : oKeys; +}; + +// `Reflect.getMetadataKeys` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + getMetadataKeys: function getMetadataKeys(target /* , targetKey */) { + var targetKey = arguments.length < 2 ? undefined : toMetadataKey(arguments[1]); + return ordinaryMetadataKeys(anObject(target), targetKey); + } +}); + + +/***/ }), +/* 712 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); + +var ordinaryGetOwnMetadata = ReflectMetadataModule.get; +var toMetadataKey = ReflectMetadataModule.toKey; + +// `Reflect.getOwnMetadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); + return ordinaryGetOwnMetadata(metadataKey, anObject(target), targetKey); + } +}); + + +/***/ }), +/* 713 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); + +var ordinaryOwnMetadataKeys = ReflectMetadataModule.keys; +var toMetadataKey = ReflectMetadataModule.toKey; + +// `Reflect.getOwnMetadataKeys` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) { + var targetKey = arguments.length < 2 ? undefined : toMetadataKey(arguments[1]); + return ordinaryOwnMetadataKeys(anObject(target), targetKey); + } +}); + + +/***/ }), +/* 714 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); +var getPrototypeOf = __webpack_require__(134); + +var ordinaryHasOwnMetadata = ReflectMetadataModule.has; +var toMetadataKey = ReflectMetadataModule.toKey; + +var ordinaryHasMetadata = function (MetadataKey, O, P) { + var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) return true; + var parent = getPrototypeOf(O); + return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false; +}; + +// `Reflect.hasMetadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); + return ordinaryHasMetadata(metadataKey, anObject(target), targetKey); + } +}); + + +/***/ }), +/* 715 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); + +var ordinaryHasOwnMetadata = ReflectMetadataModule.has; +var toMetadataKey = ReflectMetadataModule.toKey; + +// `Reflect.hasOwnMetadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) { + var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]); + return ordinaryHasOwnMetadata(metadataKey, anObject(target), targetKey); + } +}); + + +/***/ }), +/* 716 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var ReflectMetadataModule = __webpack_require__(708); +var anObject = __webpack_require__(46); + +var toMetadataKey = ReflectMetadataModule.toKey; +var ordinaryDefineOwnMetadata = ReflectMetadataModule.set; + +// `Reflect.metadata` method +// https://github.com/rbuckton/reflect-metadata +$({ target: 'Reflect', stat: true }, { + metadata: function metadata(metadataKey, metadataValue) { + return function decorator(target, key) { + ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetadataKey(key)); + }; + } +}); + + +/***/ }), +/* 717 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aSet = __webpack_require__(452); +var add = __webpack_require__(453).add; + +// `Set.prototype.addAll` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + addAll: function addAll(/* ...elements */) { + var set = aSet(this); + for (var k = 0, len = arguments.length; k < len; k++) { + add(set, arguments[k]); + } return set; + } +}); + + +/***/ }), +/* 718 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aSet = __webpack_require__(452); +var remove = __webpack_require__(453).remove; + +// `Set.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + deleteAll: function deleteAll(/* ...elements */) { + var collection = aSet(this); + var allDeleted = true; + var wasDeleted; + for (var k = 0, len = arguments.length; k < len; k++) { + wasDeleted = remove(collection, arguments[k]); + allDeleted = allDeleted && wasDeleted; + } return !!allDeleted; + } +}); + + +/***/ }), +/* 719 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $difference = __webpack_require__(451); + +// `Set.prototype.difference` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + difference: function difference(other) { + return call($difference, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 720 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var isCallable = __webpack_require__(21); +var isIterable = __webpack_require__(721); +var isObject = __webpack_require__(20); + +var Set = getBuiltIn('Set'); + +var isSetLike = function (it) { + return isObject(it) + && typeof it.size == 'number' + && isCallable(it.has) + && isCallable(it.keys); +}; + +// fallback old -> new set methods proposal arguments +module.exports = function (it) { + if (isSetLike(it)) return it; + return isIterable(it) ? new Set(it) : it; +}; + + +/***/ }), +/* 721 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(69); +var hasOwn = __webpack_require__(38); +var isNullOrUndefined = __webpack_require__(17); +var wellKnownSymbol = __webpack_require__(33); +var Iterators = __webpack_require__(138); + +var ITERATOR = wellKnownSymbol('iterator'); +var $Object = Object; + +module.exports = function (it) { + if (isNullOrUndefined(it)) return false; + var O = $Object(it); + return O[ITERATOR] !== undefined + || '@@iterator' in O + || hasOwn(Iterators, classof(O)); +}; + + +/***/ }), +/* 722 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aSet = __webpack_require__(452); +var iterate = __webpack_require__(455); + +// `Set.prototype.every` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + every: function every(callbackfn /* , thisArg */) { + var set = aSet(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return iterate(set, function (value) { + if (!boundFunction(value, value, set)) return false; + }, true) !== false; + } +}); + + +/***/ }), +/* 723 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aSet = __webpack_require__(452); +var SetHelpers = __webpack_require__(453); +var iterate = __webpack_require__(455); + +var Set = SetHelpers.Set; +var add = SetHelpers.add; + +// `Set.prototype.filter` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + filter: function filter(callbackfn /* , thisArg */) { + var set = aSet(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var newSet = new Set(); + iterate(set, function (value) { + if (boundFunction(value, value, set)) add(newSet, value); + }); + return newSet; + } +}); + + +/***/ }), +/* 724 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aSet = __webpack_require__(452); +var iterate = __webpack_require__(455); + +// `Set.prototype.find` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + find: function find(callbackfn /* , thisArg */) { + var set = aSet(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var result = iterate(set, function (value) { + if (boundFunction(value, value, set)) return { value: value }; + }, true); + return result && result.value; + } +}); + + +/***/ }), +/* 725 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var SetHelpers = __webpack_require__(453); +var createCollectionFrom = __webpack_require__(664); + +// `Set.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from +$({ target: 'Set', stat: true, forced: true }, { + from: createCollectionFrom(SetHelpers.Set, SetHelpers.add, false) +}); + + +/***/ }), +/* 726 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $intersection = __webpack_require__(461); + +// `Set.prototype.intersection` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + intersection: function intersection(other) { + return call($intersection, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 727 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $isDisjointFrom = __webpack_require__(463); + +// `Set.prototype.isDisjointFrom` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + isDisjointFrom: function isDisjointFrom(other) { + return call($isDisjointFrom, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 728 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $isSubsetOf = __webpack_require__(465); + +// `Set.prototype.isSubsetOf` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + isSubsetOf: function isSubsetOf(other) { + return call($isSubsetOf, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 729 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $isSupersetOf = __webpack_require__(467); + +// `Set.prototype.isSupersetOf` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + isSupersetOf: function isSupersetOf(other) { + return call($isSupersetOf, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 730 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var uncurryThis = __webpack_require__(14); +var aSet = __webpack_require__(452); +var iterate = __webpack_require__(455); +var toString = __webpack_require__(68); + +var arrayJoin = uncurryThis([].join); +var push = uncurryThis([].push); + +// `Set.prototype.join` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + join: function join(separator) { + var set = aSet(this); + var sep = separator === undefined ? ',' : toString(separator); + var array = []; + iterate(set, function (value) { + push(array, value); + }); + return arrayJoin(array, sep); + } +}); + + +/***/ }), +/* 731 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aSet = __webpack_require__(452); +var SetHelpers = __webpack_require__(453); +var iterate = __webpack_require__(455); + +var Set = SetHelpers.Set; +var add = SetHelpers.add; + +// `Set.prototype.map` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + map: function map(callbackfn /* , thisArg */) { + var set = aSet(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var newSet = new Set(); + iterate(set, function (value) { + add(newSet, boundFunction(value, value, set)); + }); + return newSet; + } +}); + + +/***/ }), +/* 732 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var SetHelpers = __webpack_require__(453); +var createCollectionOf = __webpack_require__(673); + +// `Set.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of +$({ target: 'Set', stat: true, forced: true }, { + of: createCollectionOf(SetHelpers.Set, SetHelpers.add, false) +}); + + +/***/ }), +/* 733 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aCallable = __webpack_require__(30); +var aSet = __webpack_require__(452); +var iterate = __webpack_require__(455); + +var $TypeError = TypeError; + +// `Set.prototype.reduce` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + reduce: function reduce(callbackfn /* , initialValue */) { + var set = aSet(this); + var noInitial = arguments.length < 2; + var accumulator = noInitial ? undefined : arguments[1]; + aCallable(callbackfn); + iterate(set, function (value) { + if (noInitial) { + noInitial = false; + accumulator = value; + } else { + accumulator = callbackfn(accumulator, value, value, set); + } + }); + if (noInitial) throw new $TypeError('Reduce of empty set with no initial value'); + return accumulator; + } +}); + + +/***/ }), +/* 734 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var bind = __webpack_require__(84); +var aSet = __webpack_require__(452); +var iterate = __webpack_require__(455); + +// `Set.prototype.some` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'Set', proto: true, real: true, forced: true }, { + some: function some(callbackfn /* , thisArg */) { + var set = aSet(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return iterate(set, function (value) { + if (boundFunction(value, value, set)) return true; + }, true) === true; + } +}); + + +/***/ }), +/* 735 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $symmetricDifference = __webpack_require__(469); + +// `Set.prototype.symmetricDifference` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + symmetricDifference: function symmetricDifference(other) { + return call($symmetricDifference, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 736 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); +var toSetLike = __webpack_require__(720); +var $union = __webpack_require__(472); + +// `Set.prototype.union` method +// https://github.com/tc39/proposal-set-methods +// TODO: Obsolete version, remove from `core-js@4` +$({ target: 'Set', proto: true, real: true, forced: true }, { + union: function union(other) { + return call($union, this, toSetLike(other)); + } +}); + + +/***/ }), +/* 737 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var $ = __webpack_require__(3); +var charAt = __webpack_require__(475).charAt; +var requireObjectCoercible = __webpack_require__(16); +var toIntegerOrInfinity = __webpack_require__(61); +var toString = __webpack_require__(68); + +// `String.prototype.at` method +// https://github.com/mathiasbynens/String.prototype.at +$({ target: 'String', proto: true, forced: true }, { + at: function at(index) { + var S = toString(requireObjectCoercible(this)); + var len = S.length; + var relativeIndex = toIntegerOrInfinity(index); + var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex; + return (k < 0 || k >= len) ? undefined : charAt(S, k); + } +}); + + +/***/ }), +/* 738 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var cooked = __webpack_require__(739); + +// `String.cooked` method +// https://github.com/tc39/proposal-string-cooked +$({ target: 'String', stat: true, forced: true }, { + cooked: cooked +}); + + +/***/ }), +/* 739 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var toIndexedObject = __webpack_require__(12); +var toString = __webpack_require__(68); +var lengthOfArrayLike = __webpack_require__(63); + +var $TypeError = TypeError; +var push = uncurryThis([].push); +var join = uncurryThis([].join); + +// `String.cooked` method +// https://tc39.es/proposal-string-cooked/ +module.exports = function cooked(template /* , ...substitutions */) { + var cookedTemplate = toIndexedObject(template); + var literalSegments = lengthOfArrayLike(cookedTemplate); + if (!literalSegments) return ''; + var argumentsLength = arguments.length; + var elements = []; + var i = 0; + while (true) { + var nextVal = cookedTemplate[i++]; + if (nextVal === undefined) throw new $TypeError('Incorrect template'); + push(elements, toString(nextVal)); + if (i === literalSegments) return join(elements, ''); + if (i < argumentsLength) push(elements, toString(arguments[i])); + } +}; + + +/***/ }), +/* 740 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var createIteratorConstructor = __webpack_require__(177); +var createIterResultObject = __webpack_require__(179); +var requireObjectCoercible = __webpack_require__(16); +var toString = __webpack_require__(68); +var InternalStateModule = __webpack_require__(51); +var StringMultibyteModule = __webpack_require__(475); + +var codeAt = StringMultibyteModule.codeAt; +var charAt = StringMultibyteModule.charAt; +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + +// TODO: unify with String#@@iterator +var $StringIterator = createIteratorConstructor(function StringIterator(string) { + setInternalState(this, { + type: STRING_ITERATOR, + string: string, + index: 0 + }); +}, 'String', function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject({ codePoint: codeAt(point, 0), position: index }, false); +}); + +// `String.prototype.codePoints` method +// https://github.com/tc39/proposal-string-prototype-codepoints +$({ target: 'String', proto: true, forced: true }, { + codePoints: function codePoints() { + return new $StringIterator(toString(requireObjectCoercible(this))); + } +}); + + +/***/ }), +/* 741 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var FREEZING = __webpack_require__(287); +var $ = __webpack_require__(3); +var makeBuiltIn = __webpack_require__(48); +var uncurryThis = __webpack_require__(14); +var apply = __webpack_require__(95); +var anObject = __webpack_require__(46); +var toObject = __webpack_require__(39); +var isCallable = __webpack_require__(21); +var lengthOfArrayLike = __webpack_require__(63); +var defineProperty = __webpack_require__(44).f; +var createArrayFromList = __webpack_require__(76); +var WeakMapHelpers = __webpack_require__(589); +var cooked = __webpack_require__(739); +var parse = __webpack_require__(742); +var whitespaces = __webpack_require__(326); + +var DedentMap = new WeakMapHelpers.WeakMap(); +var weakMapGet = WeakMapHelpers.get; +var weakMapHas = WeakMapHelpers.has; +var weakMapSet = WeakMapHelpers.set; + +var $Array = Array; +var $TypeError = TypeError; +// eslint-disable-next-line es/no-object-freeze -- safe +var freeze = Object.freeze || Object; +// eslint-disable-next-line es/no-object-isfrozen -- safe +var isFrozen = Object.isFrozen; +var min = Math.min; +var charAt = uncurryThis(''.charAt); +var stringSlice = uncurryThis(''.slice); +var split = uncurryThis(''.split); +var exec = uncurryThis(/./.exec); + +var NEW_LINE = /([\n\u2028\u2029]|\r\n?)/g; +var LEADING_WHITESPACE = RegExp('^[' + whitespaces + ']*'); +var NON_WHITESPACE = RegExp('[^' + whitespaces + ']'); +var INVALID_TAG = 'Invalid tag'; +var INVALID_OPENING_LINE = 'Invalid opening line'; +var INVALID_CLOSING_LINE = 'Invalid closing line'; + +var dedentTemplateStringsArray = function (template) { + var rawInput = template.raw; + // https://github.com/tc39/proposal-string-dedent/issues/75 + if (FREEZING && !isFrozen(rawInput)) throw new $TypeError('Raw template should be frozen'); + if (weakMapHas(DedentMap, rawInput)) return weakMapGet(DedentMap, rawInput); + var raw = dedentStringsArray(rawInput); + var cookedArr = cookStrings(raw); + defineProperty(cookedArr, 'raw', { + value: freeze(raw) + }); + freeze(cookedArr); + weakMapSet(DedentMap, rawInput, cookedArr); + return cookedArr; +}; + +var dedentStringsArray = function (template) { + var t = toObject(template); + var length = lengthOfArrayLike(t); + var blocks = $Array(length); + var dedented = $Array(length); + var i = 0; + var lines, common, quasi, k; + + if (!length) throw new $TypeError(INVALID_TAG); + + for (; i < length; i++) { + var element = t[i]; + if (typeof element == 'string') blocks[i] = split(element, NEW_LINE); + else throw new $TypeError(INVALID_TAG); + } + + for (i = 0; i < length; i++) { + var lastSplit = i + 1 === length; + lines = blocks[i]; + if (i === 0) { + if (lines.length === 1 || lines[0].length > 0) { + throw new $TypeError(INVALID_OPENING_LINE); + } + lines[1] = ''; + } + if (lastSplit) { + if (lines.length === 1 || exec(NON_WHITESPACE, lines[lines.length - 1])) { + throw new $TypeError(INVALID_CLOSING_LINE); + } + lines[lines.length - 2] = ''; + lines[lines.length - 1] = ''; + } + + for (var j = 2; j < lines.length; j += 2) { + var text = lines[j]; + var lineContainsTemplateExpression = j + 1 === lines.length && !lastSplit; + var leading = exec(LEADING_WHITESPACE, text)[0]; + if (!lineContainsTemplateExpression && leading.length === text.length) { + lines[j] = ''; + continue; + } + common = commonLeadingIndentation(leading, common); + } + } + + var count = common ? common.length : 0; + + for (i = 0; i < length; i++) { + lines = blocks[i]; + quasi = lines[0]; + k = 1; + for (; k < lines.length; k += 2) { + quasi += lines[k] + stringSlice(lines[k + 1], count); + } + dedented[i] = quasi; + } + + return dedented; +}; + +var commonLeadingIndentation = function (a, b) { + if (b === undefined || a === b) return a; + var i = 0; + for (var len = min(a.length, b.length); i < len; i++) { + if (charAt(a, i) !== charAt(b, i)) break; + } + return stringSlice(a, 0, i); +}; + +var cookStrings = function (raw) { + var i = 0; + var length = raw.length; + var result = $Array(length); + for (; i < length; i++) { + result[i] = parse(raw[i]); + } return result; +}; + +var makeDedentTag = function (tag) { + return makeBuiltIn(function (template /* , ...substitutions */) { + var args = createArrayFromList(arguments); + args[0] = dedentTemplateStringsArray(anObject(template)); + return apply(tag, this, args); + }, ''); +}; + +var cookedDedentTag = makeDedentTag(cooked); + +// `String.dedent` method +// https://github.com/tc39/proposal-string-dedent +$({ target: 'String', stat: true, forced: true }, { + dedent: function dedent(templateOrFn /* , ...substitutions */) { + anObject(templateOrFn); + if (isCallable(templateOrFn)) return makeDedentTag(templateOrFn); + return apply(cookedDedentTag, this, arguments); + } +}); + + +/***/ }), +/* 742 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// adapted from https://github.com/jridgewell/string-dedent +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); + +var fromCharCode = String.fromCharCode; +var fromCodePoint = getBuiltIn('String', 'fromCodePoint'); +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var stringIndexOf = uncurryThis(''.indexOf); +var stringSlice = uncurryThis(''.slice); + +var ZERO_CODE = 48; +var NINE_CODE = 57; +var LOWER_A_CODE = 97; +var LOWER_F_CODE = 102; +var UPPER_A_CODE = 65; +var UPPER_F_CODE = 70; + +var isDigit = function (str, index) { + var c = charCodeAt(str, index); + return c >= ZERO_CODE && c <= NINE_CODE; +}; + +var parseHex = function (str, index, end) { + if (end > str.length || index >= end) return -1; + var n = 0; + for (; index < end; index++) { + var c = hexToInt(charCodeAt(str, index)); + if (c === -1) return -1; + n = n * 16 + c; + } + return n; +}; + +var hexToInt = function (c) { + if (c >= ZERO_CODE && c <= NINE_CODE) return c - ZERO_CODE; + if (c >= LOWER_A_CODE && c <= LOWER_F_CODE) return c - LOWER_A_CODE + 10; + if (c >= UPPER_A_CODE && c <= UPPER_F_CODE) return c - UPPER_A_CODE + 10; + return -1; +}; + +module.exports = function (raw) { + var out = ''; + var start = 0; + // We need to find every backslash escape sequence, and cook the escape into a real char. + var i = 0; + var n; + while ((i = stringIndexOf(raw, '\\', i)) > -1) { + out += stringSlice(raw, start, i); + // If the backslash is the last char of the string, then it was an invalid sequence. + // This can't actually happen in a tagged template literal, but could happen if you manually + // invoked the tag with an array. + if (++i === raw.length) return; + var next = charAt(raw, i++); + switch (next) { + // Escaped control codes need to be individually processed. + case 'b': + out += '\b'; + break; + case 't': + out += '\t'; + break; + case 'n': + out += '\n'; + break; + case 'v': + out += '\v'; + break; + case 'f': + out += '\f'; + break; + case 'r': + out += '\r'; + break; + // Escaped line terminators just skip the char. + case '\r': + // Treat `\r\n` as a single terminator. + if (i < raw.length && charAt(raw, i) === '\n') ++i; + // break omitted + case '\n': + case '\u2028': + case '\u2029': + break; + // `\0` is a null control char, but `\0` followed by another digit is an illegal octal escape. + case '0': + if (isDigit(raw, i)) return; + out += '\0'; + break; + // Hex escapes must contain 2 hex chars. + case 'x': + n = parseHex(raw, i, i + 2); + if (n === -1) return; + i += 2; + out += fromCharCode(n); + break; + // Unicode escapes contain either 4 chars, or an unlimited number between `{` and `}`. + // The hex value must not overflow 0x10FFFF. + case 'u': + if (i < raw.length && charAt(raw, i) === '{') { + var end = stringIndexOf(raw, '}', ++i); + if (end === -1) return; + n = parseHex(raw, i, end); + i = end + 1; + } else { + n = parseHex(raw, i, i + 4); + i += 4; + } + if (n === -1 || n > 0x10FFFF) return; + out += fromCodePoint(n); + break; + default: + if (isDigit(next, 0)) return; + out += next; + } + start = i; + } + return out + stringSlice(raw, start); +}; + + +/***/ }), +/* 743 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.customMatcher` well-known symbol +// https://github.com/tc39/proposal-pattern-matching +defineWellKnownSymbol('customMatcher'); + + +/***/ }), +/* 744 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isRegisteredSymbol = __webpack_require__(745); + +// `Symbol.isRegisteredSymbol` method +// https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol +$({ target: 'Symbol', stat: true }, { + isRegisteredSymbol: isRegisteredSymbol +}); + + +/***/ }), +/* 745 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); + +var Symbol = getBuiltIn('Symbol'); +var keyFor = Symbol.keyFor; +var thisSymbolValue = uncurryThis(Symbol.prototype.valueOf); + +// `Symbol.isRegisteredSymbol` method +// https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol +module.exports = Symbol.isRegisteredSymbol || function isRegisteredSymbol(value) { + try { + return keyFor(thisSymbolValue(value)) !== undefined; + } catch (error) { + return false; + } +}; + + +/***/ }), +/* 746 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isRegisteredSymbol = __webpack_require__(745); + +// `Symbol.isRegistered` method +// obsolete version of https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol +$({ target: 'Symbol', stat: true, name: 'isRegisteredSymbol' }, { + isRegistered: isRegisteredSymbol +}); + + +/***/ }), +/* 747 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isWellKnownSymbol = __webpack_require__(748); + +// `Symbol.isWellKnownSymbol` method +// https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol +// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected +$({ target: 'Symbol', stat: true, forced: true }, { + isWellKnownSymbol: isWellKnownSymbol +}); + + +/***/ }), +/* 748 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var shared = __webpack_require__(34); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var isSymbol = __webpack_require__(22); +var wellKnownSymbol = __webpack_require__(33); + +var Symbol = getBuiltIn('Symbol'); +var $isWellKnownSymbol = Symbol.isWellKnownSymbol; +var getOwnPropertyNames = getBuiltIn('Object', 'getOwnPropertyNames'); +var thisSymbolValue = uncurryThis(Symbol.prototype.valueOf); +var WellKnownSymbolsStore = shared('wks'); + +for (var i = 0, symbolKeys = getOwnPropertyNames(Symbol), symbolKeysLength = symbolKeys.length; i < symbolKeysLength; i++) { + // some old engines throws on access to some keys like `arguments` or `caller` + try { + var symbolKey = symbolKeys[i]; + if (isSymbol(Symbol[symbolKey])) wellKnownSymbol(symbolKey); + } catch (error) { /* empty */ } +} + +// `Symbol.isWellKnownSymbol` method +// https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol +// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected +module.exports = function isWellKnownSymbol(value) { + if ($isWellKnownSymbol && $isWellKnownSymbol(value)) return true; + try { + var symbol = thisSymbolValue(value); + for (var j = 0, keys = getOwnPropertyNames(WellKnownSymbolsStore), keysLength = keys.length; j < keysLength; j++) { + // eslint-disable-next-line eqeqeq -- polyfilled symbols case + if (WellKnownSymbolsStore[keys[j]] == symbol) return true; + } + } catch (error) { /* empty */ } + return false; +}; + + +/***/ }), +/* 749 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var isWellKnownSymbol = __webpack_require__(748); + +// `Symbol.isWellKnown` method +// obsolete version of https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol +// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected +$({ target: 'Symbol', stat: true, name: 'isWellKnownSymbol', forced: true }, { + isWellKnown: isWellKnownSymbol +}); + + +/***/ }), +/* 750 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.matcher` well-known symbol +// https://github.com/tc39/proposal-pattern-matching +defineWellKnownSymbol('matcher'); + + +/***/ }), +/* 751 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.metadata` well-known symbol +// https://github.com/tc39/proposal-decorators +defineWellKnownSymbol('metadata'); + + +/***/ }), +/* 752 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.metadataKey` well-known symbol +// https://github.com/tc39/proposal-decorator-metadata +defineWellKnownSymbol('metadataKey'); + + +/***/ }), +/* 753 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.observable` well-known symbol +// https://github.com/tc39/proposal-observable +defineWellKnownSymbol('observable'); + + +/***/ }), +/* 754 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: remove from `core-js@4` +var defineWellKnownSymbol = __webpack_require__(79); + +// `Symbol.patternMatch` well-known symbol +// https://github.com/tc39/proposal-pattern-matching +defineWellKnownSymbol('patternMatch'); + + +/***/ }), +/* 755 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: remove from `core-js@4` +var defineWellKnownSymbol = __webpack_require__(79); + +defineWellKnownSymbol('replaceAll'); + + +/***/ }), +/* 756 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var getBuiltIn = __webpack_require__(23); +var aConstructor = __webpack_require__(381); +var arrayFromAsync = __webpack_require__(408); +var ArrayBufferViewCore = __webpack_require__(223); +var arrayFromConstructorAndList = __webpack_require__(204); + +var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor; +var exportTypedArrayStaticMethod = ArrayBufferViewCore.exportTypedArrayStaticMethod; + +// `%TypedArray%.fromAsync` method +// https://github.com/tc39/proposal-array-from-async +exportTypedArrayStaticMethod('fromAsync', function fromAsync(asyncItems /* , mapfn = undefined, thisArg = undefined */) { + var C = this; + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var thisArg = argumentsLength > 2 ? arguments[2] : undefined; + return new (getBuiltIn('Promise'))(function (resolve) { + aConstructor(C); + resolve(arrayFromAsync(asyncItems, mapfn, thisArg)); + }).then(function (list) { + return arrayFromConstructorAndList(aTypedArrayConstructor(C), list); + }); +}, true); + + +/***/ }), +/* 757 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var ArrayBufferViewCore = __webpack_require__(223); +var $filterReject = __webpack_require__(83).filterReject; +var fromSameTypeAndList = __webpack_require__(545); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.filterOut` method +// https://github.com/tc39/proposal-array-filtering +exportTypedArrayMethod('filterOut', function filterOut(callbackfn /* , thisArg */) { + var list = $filterReject(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return fromSameTypeAndList(this, list); +}, true); + + +/***/ }), +/* 758 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(223); +var $filterReject = __webpack_require__(83).filterReject; +var fromSameTypeAndList = __webpack_require__(545); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.filterReject` method +// https://github.com/tc39/proposal-array-filtering +exportTypedArrayMethod('filterReject', function filterReject(callbackfn /* , thisArg */) { + var list = $filterReject(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined); + return fromSameTypeAndList(this, list); +}, true); + + +/***/ }), +/* 759 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var ArrayBufferViewCore = __webpack_require__(223); +var $group = __webpack_require__(598); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +// `%TypedArray%.prototype.groupBy` method +// https://github.com/tc39/proposal-array-grouping +exportTypedArrayMethod('groupBy', function groupBy(callbackfn /* , thisArg */) { + var thisArg = arguments.length > 1 ? arguments[1] : undefined; + return $group(aTypedArray(this), callbackfn, thisArg, getTypedArrayConstructor); +}, true); + + +/***/ }), +/* 760 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove from `core-js@4` +var ArrayBufferViewCore = __webpack_require__(223); +var lengthOfArrayLike = __webpack_require__(63); +var isBigIntArray = __webpack_require__(530); +var toAbsoluteIndex = __webpack_require__(60); +var toBigInt = __webpack_require__(531); +var toIntegerOrInfinity = __webpack_require__(61); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var max = Math.max; +var min = Math.min; + +// `%TypedArray%.prototype.toSpliced` method +// https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toSpliced +exportTypedArrayMethod('toSpliced', function toSpliced(start, deleteCount /* , ...items */) { + var O = aTypedArray(this); + var C = getTypedArrayConstructor(O); + var len = lengthOfArrayLike(O); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var k = 0; + var insertCount, actualDeleteCount, thisIsBigIntArray, convertedItems, value, newLen, A; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart); + insertCount = argumentsLength - 2; + if (insertCount) { + convertedItems = new C(insertCount); + thisIsBigIntArray = isBigIntArray(convertedItems); + for (var i = 2; i < argumentsLength; i++) { + value = arguments[i]; + // FF30- typed arrays doesn't properly convert objects to typed array values + convertedItems[i - 2] = thisIsBigIntArray ? toBigInt(value) : +value; + } + } + } + newLen = len + insertCount - actualDeleteCount; + A = new C(newLen); + + for (; k < actualStart; k++) A[k] = O[k]; + for (; k < actualStart + insertCount; k++) A[k] = convertedItems[k - actualStart]; + for (; k < newLen; k++) A[k] = O[k + actualDeleteCount - insertCount]; + + return A; +}, true); + + +/***/ }), +/* 761 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); +var ArrayBufferViewCore = __webpack_require__(223); +var arrayFromConstructorAndList = __webpack_require__(204); +var $arrayUniqueBy = __webpack_require__(607); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var arrayUniqueBy = uncurryThis($arrayUniqueBy); + +// `%TypedArray%.prototype.uniqueBy` method +// https://github.com/tc39/proposal-array-unique +exportTypedArrayMethod('uniqueBy', function uniqueBy(resolver) { + aTypedArray(this); + return arrayFromConstructorAndList(getTypedArrayConstructor(this), arrayUniqueBy(this, resolver)); +}, true); + + +/***/ }), +/* 762 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aWeakMap = __webpack_require__(591); +var remove = __webpack_require__(589).remove; + +// `WeakMap.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'WeakMap', proto: true, real: true, forced: true }, { + deleteAll: function deleteAll(/* ...elements */) { + var collection = aWeakMap(this); + var allDeleted = true; + var wasDeleted; + for (var k = 0, len = arguments.length; k < len; k++) { + wasDeleted = remove(collection, arguments[k]); + allDeleted = allDeleted && wasDeleted; + } return !!allDeleted; + } +}); + + +/***/ }), +/* 763 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var WeakMapHelpers = __webpack_require__(589); +var createCollectionFrom = __webpack_require__(664); + +// `WeakMap.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from +$({ target: 'WeakMap', stat: true, forced: true }, { + from: createCollectionFrom(WeakMapHelpers.WeakMap, WeakMapHelpers.set, true) +}); + + +/***/ }), +/* 764 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var WeakMapHelpers = __webpack_require__(589); +var createCollectionOf = __webpack_require__(673); + +// `WeakMap.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of +$({ target: 'WeakMap', stat: true, forced: true }, { + of: createCollectionOf(WeakMapHelpers.WeakMap, WeakMapHelpers.set, true) +}); + + +/***/ }), +/* 765 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aWeakMap = __webpack_require__(591); +var WeakMapHelpers = __webpack_require__(589); + +var get = WeakMapHelpers.get; +var has = WeakMapHelpers.has; +var set = WeakMapHelpers.set; + +// `WeakMap.prototype.emplace` method +// https://github.com/tc39/proposal-upsert +$({ target: 'WeakMap', proto: true, real: true, forced: true }, { + emplace: function emplace(key, handler) { + var map = aWeakMap(this); + var value, inserted; + if (has(map, key)) { + value = get(map, key); + if ('update' in handler) { + value = handler.update(value, key, map); + set(map, key, value); + } return value; + } + inserted = handler.insert(key, map); + set(map, key, inserted); + return inserted; + } +}); + + +/***/ }), +/* 766 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: remove from `core-js@4` +var $ = __webpack_require__(3); +var upsert = __webpack_require__(678); + +// `WeakMap.prototype.upsert` method (replaced by `WeakMap.prototype.emplace`) +// https://github.com/tc39/proposal-upsert +$({ target: 'WeakMap', proto: true, real: true, forced: true }, { + upsert: upsert +}); + + +/***/ }), +/* 767 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aWeakSet = __webpack_require__(768); +var add = __webpack_require__(769).add; + +// `WeakSet.prototype.addAll` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'WeakSet', proto: true, real: true, forced: true }, { + addAll: function addAll(/* ...elements */) { + var set = aWeakSet(this); + for (var k = 0, len = arguments.length; k < len; k++) { + add(set, arguments[k]); + } return set; + } +}); + + +/***/ }), +/* 768 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var has = __webpack_require__(769).has; + +// Perform ? RequireInternalSlot(M, [[WeakSetData]]) +module.exports = function (it) { + has(it); + return it; +}; + + +/***/ }), +/* 769 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(14); + +// eslint-disable-next-line es/no-weak-set -- safe +var WeakSetPrototype = WeakSet.prototype; + +module.exports = { + // eslint-disable-next-line es/no-weak-set -- safe + WeakSet: WeakSet, + add: uncurryThis(WeakSetPrototype.add), + has: uncurryThis(WeakSetPrototype.has), + remove: uncurryThis(WeakSetPrototype['delete']) +}; + + +/***/ }), +/* 770 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var aWeakSet = __webpack_require__(768); +var remove = __webpack_require__(769).remove; + +// `WeakSet.prototype.deleteAll` method +// https://github.com/tc39/proposal-collection-methods +$({ target: 'WeakSet', proto: true, real: true, forced: true }, { + deleteAll: function deleteAll(/* ...elements */) { + var collection = aWeakSet(this); + var allDeleted = true; + var wasDeleted; + for (var k = 0, len = arguments.length; k < len; k++) { + wasDeleted = remove(collection, arguments[k]); + allDeleted = allDeleted && wasDeleted; + } return !!allDeleted; + } +}); + + +/***/ }), +/* 771 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var WeakSetHelpers = __webpack_require__(769); +var createCollectionFrom = __webpack_require__(664); + +// `WeakSet.from` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from +$({ target: 'WeakSet', stat: true, forced: true }, { + from: createCollectionFrom(WeakSetHelpers.WeakSet, WeakSetHelpers.add, false) +}); + + +/***/ }), +/* 772 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var WeakSetHelpers = __webpack_require__(769); +var createCollectionOf = __webpack_require__(673); + +// `WeakSet.of` method +// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of +$({ target: 'WeakSet', stat: true, forced: true }, { + of: createCollectionOf(WeakSetHelpers.WeakSet, WeakSetHelpers.add, false) +}); + + +/***/ }), +/* 773 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var call = __webpack_require__(8); +var fails = __webpack_require__(7); +var toString = __webpack_require__(68); +var validateArgumentsLength = __webpack_require__(383); +var c2i = __webpack_require__(575).c2i; + +var disallowed = /[^\d+/a-z]/i; +var whitespaces = /[\t\n\f\r ]+/g; +var finalEq = /[=]{1,2}$/; + +var $atob = getBuiltIn('atob'); +var $Array = Array; +var fromCharCode = String.fromCharCode; +var charAt = uncurryThis(''.charAt); +var replace = uncurryThis(''.replace); +var join = uncurryThis([].join); +var exec = uncurryThis(disallowed.exec); + +var BASIC = !!$atob && !fails(function () { + return $atob('aGk=') !== 'hi'; +}); + +var NO_SPACES_IGNORE = BASIC && fails(function () { + return $atob(' ') !== ''; +}); + +var NO_ENCODING_CHECK = BASIC && !fails(function () { + $atob('a'); +}); + +var NO_ARG_RECEIVING_CHECK = BASIC && !fails(function () { + $atob(); +}); + +var WRONG_ARITY = BASIC && $atob.length !== 1; + +var FORCED = !BASIC || NO_SPACES_IGNORE || NO_ENCODING_CHECK || NO_ARG_RECEIVING_CHECK || WRONG_ARITY; + +// `atob` method +// https://html.spec.whatwg.org/multipage/webappapis.html#dom-atob +$({ global: true, bind: true, enumerable: true, forced: FORCED }, { + atob: function atob(data) { + validateArgumentsLength(arguments.length, 1); + // `webpack` dev server bug on IE global methods - use call(fn, global, ...) + if (BASIC && !NO_SPACES_IGNORE && !NO_ENCODING_CHECK) return call($atob, globalThis, data); + var string = replace(toString(data), whitespaces, ''); + var position = 0; + var bc = 0; + var length, chr, bs; + if (!(string.length & 3)) { + string = replace(string, finalEq, ''); + } + length = string.length; + var lenmod = length & 3; + if (lenmod === 1 || exec(disallowed, string)) { + throw new (getBuiltIn('DOMException'))('The string is not correctly encoded', 'InvalidCharacterError'); + } + // (length >> 2) is equivalent for length / 4 floored; * 3 then multiplies the + // number of bytes for full quanta + // lenmod is length % 4; if there's 2 or 3 bytes it's 1 or 2 bytes of extra output + // respectively, so -1, however use a ternary to ensure 0 does not get -1 onto length + var output = new $Array((length >> 2) * 3 + (lenmod ? lenmod - 1 : 0)); + var outputIndex = 0; + while (position < length) { + chr = charAt(string, position++); + bs = bc & 3 ? (bs << 6) + c2i[chr] : c2i[chr]; + if (bc++ & 3) output[outputIndex++] = fromCharCode(255 & bs >> (-2 * bc & 6)); + } + return join(output, ''); + } +}); + + +/***/ }), +/* 774 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var call = __webpack_require__(8); +var fails = __webpack_require__(7); +var toString = __webpack_require__(68); +var validateArgumentsLength = __webpack_require__(383); +var i2c = __webpack_require__(575).i2c; + +var $btoa = getBuiltIn('btoa'); +var $Array = Array; +var join = uncurryThis([].join); +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); + +var BASIC = !!$btoa && !fails(function () { + return $btoa('hi') !== 'aGk='; +}); + +var NO_ARG_RECEIVING_CHECK = BASIC && !fails(function () { + $btoa(); +}); + +var WRONG_ARG_CONVERSION = BASIC && fails(function () { + return $btoa(null) !== 'bnVsbA=='; +}); + +var WRONG_ARITY = BASIC && $btoa.length !== 1; + +// `btoa` method +// https://html.spec.whatwg.org/multipage/webappapis.html#dom-btoa +$({ global: true, bind: true, enumerable: true, forced: !BASIC || NO_ARG_RECEIVING_CHECK || WRONG_ARG_CONVERSION || WRONG_ARITY }, { + btoa: function btoa(data) { + validateArgumentsLength(arguments.length, 1); + // `webpack` dev server bug on IE global methods - use call(fn, global, ...) + if (BASIC) return call($btoa, globalThis, toString(data)); + var string = toString(data); + // (string.length + 2) / 3) and then truncating to integer + // does the ceil automatically. << 2 will truncate the integer + // while also doing *4. ceil(length / 3) quanta, 4 bytes output + // per quanta for base64. + var output = new $Array((string.length + 2) / 3 << 2); + var outputIndex = 0; + var position = 0; + var map = i2c; + var block, charCode; + while (charAt(string, position) || (map = '=', position % 1)) { + charCode = charCodeAt(string, position += 3 / 4); + if (charCode > 0xFF) { + throw new (getBuiltIn('DOMException'))('The string contains characters outside of the Latin1 range', 'InvalidCharacterError'); + } + block = block << 8 | charCode; + output[outputIndex++] = charAt(map, 63 & block >> 8 - position % 1 * 8); + } return join(output, ''); + } +}); + + +/***/ }), +/* 775 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var DOMIterables = __webpack_require__(776); +var DOMTokenListPrototype = __webpack_require__(777); +var forEach = __webpack_require__(167); +var createNonEnumerableProperty = __webpack_require__(43); + +var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype); + } +} + +handlePrototype(DOMTokenListPrototype); + + +/***/ }), +/* 776 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +module.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + + +/***/ }), +/* 777 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` +var documentCreateElement = __webpack_require__(42); + +var classList = documentCreateElement('span').classList; +var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype; + +module.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype; + + +/***/ }), +/* 778 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var DOMIterables = __webpack_require__(776); +var DOMTokenListPrototype = __webpack_require__(777); +var ArrayIteratorMethods = __webpack_require__(175); +var createNonEnumerableProperty = __webpack_require__(43); +var setToStringTag = __webpack_require__(82); +var wellKnownSymbol = __webpack_require__(33); + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayValues = ArrayIteratorMethods.values; + +var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype, COLLECTION_NAME); +} + +handlePrototype(DOMTokenListPrototype, 'DOMTokenList'); + + +/***/ }), +/* 779 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var getBuiltInNodeModule = __webpack_require__(238); +var fails = __webpack_require__(7); +var create = __webpack_require__(71); +var createPropertyDescriptor = __webpack_require__(11); +var defineProperty = __webpack_require__(44).f; +var defineBuiltIn = __webpack_require__(47); +var defineBuiltInAccessor = __webpack_require__(77); +var hasOwn = __webpack_require__(38); +var anInstance = __webpack_require__(215); +var anObject = __webpack_require__(46); +var errorToString = __webpack_require__(131); +var normalizeStringArgument = __webpack_require__(124); +var DOMExceptionConstants = __webpack_require__(780); +var clearErrorStack = __webpack_require__(127); +var InternalStateModule = __webpack_require__(51); +var DESCRIPTORS = __webpack_require__(6); +var IS_PURE = __webpack_require__(36); + +var DOM_EXCEPTION = 'DOMException'; +var DATA_CLONE_ERR = 'DATA_CLONE_ERR'; +var Error = getBuiltIn('Error'); +// NodeJS < 17.0 does not expose `DOMException` to global +var NativeDOMException = getBuiltIn(DOM_EXCEPTION) || (function () { + try { + // NodeJS < 15.0 does not expose `MessageChannel` to global + var MessageChannel = getBuiltIn('MessageChannel') || getBuiltInNodeModule('worker_threads').MessageChannel; + // eslint-disable-next-line es/no-weak-map, unicorn/require-post-message-target-origin -- safe + new MessageChannel().port1.postMessage(new WeakMap()); + } catch (error) { + if (error.name === DATA_CLONE_ERR && error.code === 25) return error.constructor; + } +})(); +var NativeDOMExceptionPrototype = NativeDOMException && NativeDOMException.prototype; +var ErrorPrototype = Error.prototype; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(DOM_EXCEPTION); +var HAS_STACK = 'stack' in new Error(DOM_EXCEPTION); + +var codeFor = function (name) { + return hasOwn(DOMExceptionConstants, name) && DOMExceptionConstants[name].m ? DOMExceptionConstants[name].c : 0; +}; + +var $DOMException = function DOMException() { + anInstance(this, DOMExceptionPrototype); + var argumentsLength = arguments.length; + var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]); + var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error'); + var code = codeFor(name); + setInternalState(this, { + type: DOM_EXCEPTION, + name: name, + message: message, + code: code + }); + if (!DESCRIPTORS) { + this.name = name; + this.message = message; + this.code = code; + } + if (HAS_STACK) { + var error = new Error(message); + error.name = DOM_EXCEPTION; + defineProperty(this, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1))); + } +}; + +var DOMExceptionPrototype = $DOMException.prototype = create(ErrorPrototype); + +var createGetterDescriptor = function (get) { + return { enumerable: true, configurable: true, get: get }; +}; + +var getterFor = function (key) { + return createGetterDescriptor(function () { + return getInternalState(this)[key]; + }); +}; + +if (DESCRIPTORS) { + // `DOMException.prototype.code` getter + defineBuiltInAccessor(DOMExceptionPrototype, 'code', getterFor('code')); + // `DOMException.prototype.message` getter + defineBuiltInAccessor(DOMExceptionPrototype, 'message', getterFor('message')); + // `DOMException.prototype.name` getter + defineBuiltInAccessor(DOMExceptionPrototype, 'name', getterFor('name')); +} + +defineProperty(DOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, $DOMException)); + +// FF36- DOMException is a function, but can't be constructed +var INCORRECT_CONSTRUCTOR = fails(function () { + return !(new NativeDOMException() instanceof Error); +}); + +// Safari 10.1 / Chrome 32- / IE8- DOMException.prototype.toString bugs +var INCORRECT_TO_STRING = INCORRECT_CONSTRUCTOR || fails(function () { + return ErrorPrototype.toString !== errorToString || String(new NativeDOMException(1, 2)) !== '2: 1'; +}); + +// Deno 1.6.3- DOMException.prototype.code just missed +var INCORRECT_CODE = INCORRECT_CONSTRUCTOR || fails(function () { + return new NativeDOMException(1, 'DataCloneError').code !== 25; +}); + +// Deno 1.6.3- DOMException constants just missed +var MISSED_CONSTANTS = INCORRECT_CONSTRUCTOR + || NativeDOMException[DATA_CLONE_ERR] !== 25 + || NativeDOMExceptionPrototype[DATA_CLONE_ERR] !== 25; + +var FORCED_CONSTRUCTOR = IS_PURE ? INCORRECT_TO_STRING || INCORRECT_CODE || MISSED_CONSTANTS : INCORRECT_CONSTRUCTOR; + +// `DOMException` constructor +// https://webidl.spec.whatwg.org/#idl-DOMException +$({ global: true, constructor: true, forced: FORCED_CONSTRUCTOR }, { + DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException +}); + +var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION); +var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype; + +if (INCORRECT_TO_STRING && (IS_PURE || NativeDOMException === PolyfilledDOMException)) { + defineBuiltIn(PolyfilledDOMExceptionPrototype, 'toString', errorToString); +} + +if (INCORRECT_CODE && DESCRIPTORS && NativeDOMException === PolyfilledDOMException) { + defineBuiltInAccessor(PolyfilledDOMExceptionPrototype, 'code', createGetterDescriptor(function () { + return codeFor(anObject(this).name); + })); +} + +// `DOMException` constants +for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) { + var constant = DOMExceptionConstants[key]; + var constantName = constant.s; + var descriptor = createPropertyDescriptor(6, constant.c); + if (!hasOwn(PolyfilledDOMException, constantName)) { + defineProperty(PolyfilledDOMException, constantName, descriptor); + } + if (!hasOwn(PolyfilledDOMExceptionPrototype, constantName)) { + defineProperty(PolyfilledDOMExceptionPrototype, constantName, descriptor); + } +} + + +/***/ }), +/* 780 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +module.exports = { + IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 }, + DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 }, + HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 }, + WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 }, + InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 }, + NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 }, + NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 }, + NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 }, + NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 }, + InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 }, + InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 }, + SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 }, + InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 }, + NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 }, + InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 }, + ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 }, + TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 }, + SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 }, + NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 }, + AbortError: { s: 'ABORT_ERR', c: 20, m: 1 }, + URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 }, + QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 }, + TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 }, + InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 }, + DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 } +}; + + +/***/ }), +/* 781 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var getBuiltIn = __webpack_require__(23); +var createPropertyDescriptor = __webpack_require__(11); +var defineProperty = __webpack_require__(44).f; +var hasOwn = __webpack_require__(38); +var anInstance = __webpack_require__(215); +var inheritIfRequired = __webpack_require__(123); +var normalizeStringArgument = __webpack_require__(124); +var DOMExceptionConstants = __webpack_require__(780); +var clearErrorStack = __webpack_require__(127); +var DESCRIPTORS = __webpack_require__(6); +var IS_PURE = __webpack_require__(36); + +var DOM_EXCEPTION = 'DOMException'; +var Error = getBuiltIn('Error'); +var NativeDOMException = getBuiltIn(DOM_EXCEPTION); + +var $DOMException = function DOMException() { + anInstance(this, DOMExceptionPrototype); + var argumentsLength = arguments.length; + var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]); + var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error'); + var that = new NativeDOMException(message, name); + var error = new Error(message); + error.name = DOM_EXCEPTION; + defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1))); + inheritIfRequired(that, this, $DOMException); + return that; +}; + +var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype; + +var ERROR_HAS_STACK = 'stack' in new Error(DOM_EXCEPTION); +var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2); + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis, DOM_EXCEPTION); + +// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it +// https://github.com/Jarred-Sumner/bun/issues/399 +var BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable); + +var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK; + +// `DOMException` constructor patch for `.stack` where it's required +// https://webidl.spec.whatwg.org/#es-DOMException-specialness +$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic + DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException +}); + +var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION); +var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype; + +if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) { + if (!IS_PURE) { + defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException)); + } + + for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) { + var constant = DOMExceptionConstants[key]; + var constantName = constant.s; + if (!hasOwn(PolyfilledDOMException, constantName)) { + defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c)); + } + } +} + + +/***/ }), +/* 782 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(23); +var setToStringTag = __webpack_require__(82); + +var DOM_EXCEPTION = 'DOMException'; + +// `DOMException.prototype[@@toStringTag]` property +setToStringTag(getBuiltIn(DOM_EXCEPTION), DOM_EXCEPTION); + + +/***/ }), +/* 783 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's split to modules listed below +__webpack_require__(784); +__webpack_require__(785); + + +/***/ }), +/* 784 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var clearImmediate = __webpack_require__(382).clear; + +// `clearImmediate` method +// http://w3c.github.io/setImmediate/#si-clearImmediate +$({ global: true, bind: true, enumerable: true, forced: globalThis.clearImmediate !== clearImmediate }, { + clearImmediate: clearImmediate +}); + + +/***/ }), +/* 785 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var setTask = __webpack_require__(382).set; +var schedulersFix = __webpack_require__(786); + +// https://github.com/oven-sh/bun/issues/1633 +var setImmediate = globalThis.setImmediate ? schedulersFix(setTask, false) : setTask; + +// `setImmediate` method +// http://w3c.github.io/setImmediate/#si-setImmediate +$({ global: true, bind: true, enumerable: true, forced: globalThis.setImmediate !== setImmediate }, { + setImmediate: setImmediate +}); + + +/***/ }), +/* 786 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(4); +var apply = __webpack_require__(95); +var isCallable = __webpack_require__(21); +var ENVIRONMENT = __webpack_require__(189); +var USER_AGENT = __webpack_require__(28); +var arraySlice = __webpack_require__(76); +var validateArgumentsLength = __webpack_require__(383); + +var Function = globalThis.Function; +// dirty IE9- and Bun 0.3.0- checks +var WRAP = /MSIE .\./.test(USER_AGENT) || ENVIRONMENT === 'BUN' && (function () { + var version = globalThis.Bun.version.split('.'); + return version.length < 3 || version[0] === '0' && (version[1] < 3 || version[1] === '3' && version[2] === '0'); +})(); + +// IE9- / Bun 0.3.0- setTimeout / setInterval / setImmediate additional parameters fix +// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers +// https://github.com/oven-sh/bun/issues/1633 +module.exports = function (scheduler, hasTimeArg) { + var firstParamIndex = hasTimeArg ? 2 : 1; + return WRAP ? function (handler, timeout /* , ...arguments */) { + var boundArgs = validateArgumentsLength(arguments.length, 1) > firstParamIndex; + var fn = isCallable(handler) ? handler : Function(handler); + var params = boundArgs ? arraySlice(arguments, firstParamIndex) : []; + var callback = boundArgs ? function () { + apply(fn, this, params); + } : fn; + return hasTimeArg ? scheduler(callback, timeout) : scheduler(callback); + } : scheduler; +}; + + +/***/ }), +/* 787 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var microtask = __webpack_require__(385); +var aCallable = __webpack_require__(30); +var validateArgumentsLength = __webpack_require__(383); +var fails = __webpack_require__(7); +var DESCRIPTORS = __webpack_require__(6); + +// Bun ~ 1.0.30 bug +// https://github.com/oven-sh/bun/issues/9249 +var WRONG_ARITY = fails(function () { + // getOwnPropertyDescriptor for prevent experimental warning in Node 11 + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis, 'queueMicrotask').value.length !== 1; +}); + +// `queueMicrotask` method +// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask +$({ global: true, enumerable: true, dontCallGetSet: true, forced: WRONG_ARITY }, { + queueMicrotask: function queueMicrotask(fn) { + validateArgumentsLength(arguments.length, 1); + microtask(aCallable(fn)); + } +}); + + +/***/ }), +/* 788 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var defineBuiltInAccessor = __webpack_require__(77); +var DESCRIPTORS = __webpack_require__(6); + +var $TypeError = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty = Object.defineProperty; +var INCORRECT_VALUE = globalThis.self !== globalThis; + +// `self` getter +// https://html.spec.whatwg.org/multipage/window-object.html#dom-self +try { + if (DESCRIPTORS) { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var descriptor = Object.getOwnPropertyDescriptor(globalThis, 'self'); + // some engines have `self`, but with incorrect descriptor + // https://github.com/denoland/deno/issues/15765 + if (INCORRECT_VALUE || !descriptor || !descriptor.get || !descriptor.enumerable) { + defineBuiltInAccessor(globalThis, 'self', { + get: function self() { + return globalThis; + }, + set: function self(value) { + if (this !== globalThis) throw new $TypeError('Illegal invocation'); + defineProperty(globalThis, 'self', { + value: value, + writable: true, + configurable: true, + enumerable: true + }); + }, + configurable: true, + enumerable: true + }); + } + } else $({ global: true, simple: true, forced: INCORRECT_VALUE }, { + self: globalThis + }); +} catch (error) { /* empty */ } + + +/***/ }), +/* 789 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var IS_PURE = __webpack_require__(36); +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var getBuiltIn = __webpack_require__(23); +var uncurryThis = __webpack_require__(14); +var fails = __webpack_require__(7); +var uid = __webpack_require__(40); +var isCallable = __webpack_require__(21); +var isConstructor = __webpack_require__(89); +var isNullOrUndefined = __webpack_require__(17); +var isObject = __webpack_require__(20); +var isSymbol = __webpack_require__(22); +var iterate = __webpack_require__(136); +var anObject = __webpack_require__(46); +var classof = __webpack_require__(69); +var hasOwn = __webpack_require__(38); +var createProperty = __webpack_require__(90); +var createNonEnumerableProperty = __webpack_require__(43); +var lengthOfArrayLike = __webpack_require__(63); +var validateArgumentsLength = __webpack_require__(383); +var getRegExpFlags = __webpack_require__(433); +var MapHelpers = __webpack_require__(297); +var SetHelpers = __webpack_require__(453); +var setIterate = __webpack_require__(455); +var detachTransferable = __webpack_require__(237); +var ERROR_STACK_INSTALLABLE = __webpack_require__(128); +var PROPER_STRUCTURED_CLONE_TRANSFER = __webpack_require__(239); + +var Object = globalThis.Object; +var Array = globalThis.Array; +var Date = globalThis.Date; +var Error = globalThis.Error; +var TypeError = globalThis.TypeError; +var PerformanceMark = globalThis.PerformanceMark; +var DOMException = getBuiltIn('DOMException'); +var Map = MapHelpers.Map; +var mapHas = MapHelpers.has; +var mapGet = MapHelpers.get; +var mapSet = MapHelpers.set; +var Set = SetHelpers.Set; +var setAdd = SetHelpers.add; +var setHas = SetHelpers.has; +var objectKeys = getBuiltIn('Object', 'keys'); +var push = uncurryThis([].push); +var thisBooleanValue = uncurryThis(true.valueOf); +var thisNumberValue = uncurryThis(1.1.valueOf); +var thisStringValue = uncurryThis(''.valueOf); +var thisTimeValue = uncurryThis(Date.prototype.getTime); +var PERFORMANCE_MARK = uid('structuredClone'); +var DATA_CLONE_ERROR = 'DataCloneError'; +var TRANSFERRING = 'Transferring'; + +var checkBasicSemantic = function (structuredCloneImplementation) { + return !fails(function () { + var set1 = new globalThis.Set([7]); + var set2 = structuredCloneImplementation(set1); + var number = structuredCloneImplementation(Object(7)); + return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7; + }) && structuredCloneImplementation; +}; + +var checkErrorsCloning = function (structuredCloneImplementation, $Error) { + return !fails(function () { + var error = new $Error(); + var test = structuredCloneImplementation({ a: error, b: error }); + return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack); + }); +}; + +// https://github.com/whatwg/html/pull/5749 +var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) { + return !fails(function () { + var test = structuredCloneImplementation(new globalThis.AggregateError([1], PERFORMANCE_MARK, { cause: 3 })); + return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3; + }); +}; + +// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+ +// FF<103 and Safari implementations can't clone errors +// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604 +// FF103 can clone errors, but `.stack` of clone is an empty string +// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762 +// FF104+ fixed it on usual errors, but not on DOMExceptions +// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321 +// Chrome <102 returns `null` if cloned object contains multiple references to one error +// https://bugs.chromium.org/p/v8/issues/detail?id=12542 +// NodeJS implementation can't clone DOMExceptions +// https://github.com/nodejs/node/issues/41038 +// only FF103+ supports new (html/5749) error cloning semantic +var nativeStructuredClone = globalThis.structuredClone; + +var FORCED_REPLACEMENT = IS_PURE + || !checkErrorsCloning(nativeStructuredClone, Error) + || !checkErrorsCloning(nativeStructuredClone, DOMException) + || !checkNewErrorsCloningSemantic(nativeStructuredClone); + +// Chrome 82+, Safari 14.1+, Deno 1.11+ +// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException` +// Chrome returns `null` if cloned object contains multiple references to one error +// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround +// Safari implementation can't clone errors +// Deno 1.2-1.10 implementations too naive +// NodeJS 16.0+ does not have `PerformanceMark` constructor +// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive +// and can't clone, for example, `RegExp` or some boxed primitives +// https://github.com/nodejs/node/issues/40840 +// no one of those implementations supports new (html/5749) error cloning semantic +var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) { + return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail; +}); + +var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark; + +var throwUncloneable = function (type) { + throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR); +}; + +var throwUnpolyfillable = function (type, action) { + throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR); +}; + +var tryNativeRestrictedStructuredClone = function (value, type) { + if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type); + return nativeRestrictedStructuredClone(value); +}; + +var createDataTransfer = function () { + var dataTransfer; + try { + dataTransfer = new globalThis.DataTransfer(); + } catch (error) { + try { + dataTransfer = new globalThis.ClipboardEvent('').clipboardData; + } catch (error2) { /* empty */ } + } + return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null; +}; + +var cloneBuffer = function (value, map, $type) { + if (mapHas(map, value)) return mapGet(map, value); + + var type = $type || classof(value); + var clone, length, options, source, target, i; + + if (type === 'SharedArrayBuffer') { + if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value); + // SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original + else clone = value; + } else { + var DataView = globalThis.DataView; + + // `ArrayBuffer#slice` is not available in IE10 + // `ArrayBuffer#slice` and `DataView` are not available in old FF + if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer'); + // detached buffers throws in `DataView` and `.slice` + try { + if (isCallable(value.slice) && !value.resizable) { + clone = value.slice(0); + } else { + length = value.byteLength; + options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined; + // eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe + clone = new ArrayBuffer(length, options); + source = new DataView(value); + target = new DataView(clone); + for (i = 0; i < length; i++) { + target.setUint8(i, source.getUint8(i)); + } + } + } catch (error) { + throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR); + } + } + + mapSet(map, value, clone); + + return clone; +}; + +var cloneView = function (value, type, offset, length, map) { + var C = globalThis[type]; + // in some old engines like Safari 9, typeof C is 'object' + // on Uint8ClampedArray or some other constructors + if (!isObject(C)) throwUnpolyfillable(type); + return new C(cloneBuffer(value.buffer, map), offset, length); +}; + +var structuredCloneInternal = function (value, map) { + if (isSymbol(value)) throwUncloneable('Symbol'); + if (!isObject(value)) return value; + // effectively preserves circular references + if (map) { + if (mapHas(map, value)) return mapGet(map, value); + } else map = new Map(); + + var type = classof(value); + var C, name, cloned, dataTransfer, i, length, keys, key; + + switch (type) { + case 'Array': + cloned = Array(lengthOfArrayLike(value)); + break; + case 'Object': + cloned = {}; + break; + case 'Map': + cloned = new Map(); + break; + case 'Set': + cloned = new Set(); + break; + case 'RegExp': + // in this block because of a Safari 14.1 bug + // old FF does not clone regexes passed to the constructor, so get the source and flags directly + cloned = new RegExp(value.source, getRegExpFlags(value)); + break; + case 'Error': + name = value.name; + switch (name) { + case 'AggregateError': + cloned = new (getBuiltIn(name))([]); + break; + case 'EvalError': + case 'RangeError': + case 'ReferenceError': + case 'SuppressedError': + case 'SyntaxError': + case 'TypeError': + case 'URIError': + cloned = new (getBuiltIn(name))(); + break; + case 'CompileError': + case 'LinkError': + case 'RuntimeError': + cloned = new (getBuiltIn('WebAssembly', name))(); + break; + default: + cloned = new Error(); + } + break; + case 'DOMException': + cloned = new DOMException(value.message, value.name); + break; + case 'ArrayBuffer': + case 'SharedArrayBuffer': + cloned = cloneBuffer(value, map, type); + break; + case 'DataView': + case 'Int8Array': + case 'Uint8Array': + case 'Uint8ClampedArray': + case 'Int16Array': + case 'Uint16Array': + case 'Int32Array': + case 'Uint32Array': + case 'Float16Array': + case 'Float32Array': + case 'Float64Array': + case 'BigInt64Array': + case 'BigUint64Array': + length = type === 'DataView' ? value.byteLength : value.length; + cloned = cloneView(value, type, value.byteOffset, length, map); + break; + case 'DOMQuad': + try { + cloned = new DOMQuad( + structuredCloneInternal(value.p1, map), + structuredCloneInternal(value.p2, map), + structuredCloneInternal(value.p3, map), + structuredCloneInternal(value.p4, map) + ); + } catch (error) { + cloned = tryNativeRestrictedStructuredClone(value, type); + } + break; + case 'File': + if (nativeRestrictedStructuredClone) try { + cloned = nativeRestrictedStructuredClone(value); + // NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612 + if (classof(cloned) !== type) cloned = undefined; + } catch (error) { /* empty */ } + if (!cloned) try { + cloned = new File([value], value.name, value); + } catch (error) { /* empty */ } + if (!cloned) throwUnpolyfillable(type); + break; + case 'FileList': + dataTransfer = createDataTransfer(); + if (dataTransfer) { + for (i = 0, length = lengthOfArrayLike(value); i < length; i++) { + dataTransfer.items.add(structuredCloneInternal(value[i], map)); + } + cloned = dataTransfer.files; + } else cloned = tryNativeRestrictedStructuredClone(value, type); + break; + case 'ImageData': + // Safari 9 ImageData is a constructor, but typeof ImageData is 'object' + try { + cloned = new ImageData( + structuredCloneInternal(value.data, map), + value.width, + value.height, + { colorSpace: value.colorSpace } + ); + } catch (error) { + cloned = tryNativeRestrictedStructuredClone(value, type); + } break; + default: + if (nativeRestrictedStructuredClone) { + cloned = nativeRestrictedStructuredClone(value); + } else switch (type) { + case 'BigInt': + // can be a 3rd party polyfill + cloned = Object(value.valueOf()); + break; + case 'Boolean': + cloned = Object(thisBooleanValue(value)); + break; + case 'Number': + cloned = Object(thisNumberValue(value)); + break; + case 'String': + cloned = Object(thisStringValue(value)); + break; + case 'Date': + cloned = new Date(thisTimeValue(value)); + break; + case 'Blob': + try { + cloned = value.slice(0, value.size, value.type); + } catch (error) { + throwUnpolyfillable(type); + } break; + case 'DOMPoint': + case 'DOMPointReadOnly': + C = globalThis[type]; + try { + cloned = C.fromPoint + ? C.fromPoint(value) + : new C(value.x, value.y, value.z, value.w); + } catch (error) { + throwUnpolyfillable(type); + } break; + case 'DOMRect': + case 'DOMRectReadOnly': + C = globalThis[type]; + try { + cloned = C.fromRect + ? C.fromRect(value) + : new C(value.x, value.y, value.width, value.height); + } catch (error) { + throwUnpolyfillable(type); + } break; + case 'DOMMatrix': + case 'DOMMatrixReadOnly': + C = globalThis[type]; + try { + cloned = C.fromMatrix + ? C.fromMatrix(value) + : new C(value); + } catch (error) { + throwUnpolyfillable(type); + } break; + case 'AudioData': + case 'VideoFrame': + if (!isCallable(value.clone)) throwUnpolyfillable(type); + try { + cloned = value.clone(); + } catch (error) { + throwUncloneable(type); + } break; + case 'CropTarget': + case 'CryptoKey': + case 'FileSystemDirectoryHandle': + case 'FileSystemFileHandle': + case 'FileSystemHandle': + case 'GPUCompilationInfo': + case 'GPUCompilationMessage': + case 'ImageBitmap': + case 'RTCCertificate': + case 'WebAssembly.Module': + throwUnpolyfillable(type); + // break omitted + default: + throwUncloneable(type); + } + } + + mapSet(map, value, cloned); + + switch (type) { + case 'Array': + case 'Object': + keys = objectKeys(value); + for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) { + key = keys[i]; + createProperty(cloned, key, structuredCloneInternal(value[key], map)); + } break; + case 'Map': + value.forEach(function (v, k) { + mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map)); + }); + break; + case 'Set': + value.forEach(function (v) { + setAdd(cloned, structuredCloneInternal(v, map)); + }); + break; + case 'Error': + createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map)); + if (hasOwn(value, 'cause')) { + createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map)); + } + if (name === 'AggregateError') { + cloned.errors = structuredCloneInternal(value.errors, map); + } else if (name === 'SuppressedError') { + cloned.error = structuredCloneInternal(value.error, map); + cloned.suppressed = structuredCloneInternal(value.suppressed, map); + } // break omitted + case 'DOMException': + if (ERROR_STACK_INSTALLABLE) { + createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map)); + } + } + + return cloned; +}; + +var tryToTransfer = function (rawTransfer, map) { + if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence'); + + var transfer = []; + + iterate(rawTransfer, function (value) { + push(transfer, anObject(value)); + }); + + var i = 0; + var length = lengthOfArrayLike(transfer); + var buffers = new Set(); + var value, type, C, transferred, canvas, context; + + while (i < length) { + value = transfer[i++]; + type = classof(value); + transferred = undefined; + + if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) { + throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR); + } + + if (type === 'ArrayBuffer') { + setAdd(buffers, value); + continue; + } + + if (PROPER_STRUCTURED_CLONE_TRANSFER) { + transferred = nativeStructuredClone(value, { transfer: [value] }); + } else switch (type) { + case 'ImageBitmap': + C = globalThis.OffscreenCanvas; + if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING); + try { + canvas = new C(value.width, value.height); + context = canvas.getContext('bitmaprenderer'); + context.transferFromImageBitmap(value); + transferred = canvas.transferToImageBitmap(); + } catch (error) { /* empty */ } + break; + case 'AudioData': + case 'VideoFrame': + if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING); + try { + transferred = value.clone(); + value.close(); + } catch (error) { /* empty */ } + break; + case 'MediaSourceHandle': + case 'MessagePort': + case 'MIDIAccess': + case 'OffscreenCanvas': + case 'ReadableStream': + case 'RTCDataChannel': + case 'TransformStream': + case 'WebTransportReceiveStream': + case 'WebTransportSendStream': + case 'WritableStream': + throwUnpolyfillable(type, TRANSFERRING); + } + + if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR); + + mapSet(map, value, transferred); + } + + return buffers; +}; + +var detachBuffers = function (buffers) { + setIterate(buffers, function (buffer) { + if (PROPER_STRUCTURED_CLONE_TRANSFER) { + nativeStructuredClone(buffer, { transfer: [buffer] }); + } else if (isCallable(buffer.transfer)) { + buffer.transfer(); + } else if (detachTransferable) { + detachTransferable(buffer); + } else { + throwUnpolyfillable('ArrayBuffer', TRANSFERRING); + } + }); +}; + +// `structuredClone` method +// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone +$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, { + structuredClone: function structuredClone(value /* , { transfer } */) { + var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined; + var transfer = options ? options.transfer : undefined; + var map, buffers; + + if (transfer !== undefined) { + map = new Map(); + buffers = tryToTransfer(transfer, map); + } + + var clone = structuredCloneInternal(value, map); + + // since of an issue with cloning views of transferred buffers, we a forced to detach them later + // https://github.com/zloirock/core-js/issues/1265 + if (buffers) detachBuffers(buffers); + + return clone; + } +}); + + +/***/ }), +/* 790 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's split to modules listed below +__webpack_require__(791); +__webpack_require__(792); + + +/***/ }), +/* 791 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var schedulersFix = __webpack_require__(786); + +var setInterval = schedulersFix(globalThis.setInterval, true); + +// Bun / IE9- setInterval additional parameters fix +// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval +$({ global: true, bind: true, forced: globalThis.setInterval !== setInterval }, { + setInterval: setInterval +}); + + +/***/ }), +/* 792 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var schedulersFix = __webpack_require__(786); + +var setTimeout = schedulersFix(globalThis.setTimeout, true); + +// Bun / IE9- setTimeout additional parameters fix +// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout +$({ global: true, bind: true, forced: globalThis.setTimeout !== setTimeout }, { + setTimeout: setTimeout +}); + + +/***/ }), +/* 793 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(794); + + +/***/ }), +/* 794 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` +__webpack_require__(482); +var $ = __webpack_require__(3); +var DESCRIPTORS = __webpack_require__(6); +var USE_NATIVE_URL = __webpack_require__(795); +var globalThis = __webpack_require__(4); +var bind = __webpack_require__(84); +var uncurryThis = __webpack_require__(14); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltInAccessor = __webpack_require__(77); +var anInstance = __webpack_require__(215); +var hasOwn = __webpack_require__(38); +var assign = __webpack_require__(344); +var arrayFrom = __webpack_require__(169); +var arraySlice = __webpack_require__(76); +var codeAt = __webpack_require__(475).codeAt; +var toASCII = __webpack_require__(796); +var $toString = __webpack_require__(68); +var setToStringTag = __webpack_require__(82); +var validateArgumentsLength = __webpack_require__(383); +var URLSearchParamsModule = __webpack_require__(797); +var InternalStateModule = __webpack_require__(51); + +var setInternalState = InternalStateModule.set; +var getInternalURLState = InternalStateModule.getterFor('URL'); +var URLSearchParams = URLSearchParamsModule.URLSearchParams; +var getInternalSearchParamsState = URLSearchParamsModule.getState; + +var NativeURL = globalThis.URL; +var TypeError = globalThis.TypeError; +var encodeURIComponent = globalThis.encodeURIComponent; +var parseInt = globalThis.parseInt; +var floor = Math.floor; +var pow = Math.pow; +var charAt = uncurryThis(''.charAt); +var exec = uncurryThis(/./.exec); +var join = uncurryThis([].join); +var numberToString = uncurryThis(1.1.toString); +var pop = uncurryThis([].pop); +var push = uncurryThis([].push); +var replace = uncurryThis(''.replace); +var shift = uncurryThis([].shift); +var split = uncurryThis(''.split); +var stringSlice = uncurryThis(''.slice); +var toLowerCase = uncurryThis(''.toLowerCase); +var unshift = uncurryThis([].unshift); + +var INVALID_AUTHORITY = 'Invalid authority'; +var INVALID_SCHEME = 'Invalid scheme'; +var INVALID_HOST = 'Invalid host'; +var INVALID_PORT = 'Invalid port'; + +var ALPHA = /[a-z]/i; +var ALPHANUMERIC_PLUS_MINUS_DOT = /[\d+\-.a-z]/i; +var DIGIT = /\d/; +var HEX_START = /^0x/i; +var OCT = /^[0-7]+$/; +var DEC = /^\d+$/; +var HEX = /^[\da-f]+$/i; +/* eslint-disable regexp/no-control-character -- safe */ +var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:<>?@[\\\]^|]/; +var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:<>?@[\\\]^|]/; +var LEADING_C0_CONTROL_OR_SPACE = /^[\u0000-\u0020]+/; +var TRAILING_C0_CONTROL_OR_SPACE = /(^|[^\u0000-\u0020])[\u0000-\u0020]+$/; +var TAB_AND_NEW_LINE = /[\t\n\r]/g; +/* eslint-enable regexp/no-control-character -- safe */ +// eslint-disable-next-line no-unassigned-vars -- expected `undefined` value +var EOF; + +// https://url.spec.whatwg.org/#ends-in-a-number-checker +var endsInNumber = function (input) { + var parts = split(input, '.'); + var last, hexPart; + if (parts[parts.length - 1] === '') { + if (parts.length === 1) return false; + parts.length--; + } + last = parts[parts.length - 1]; + if (exec(DEC, last)) return true; + if (exec(HEX_START, last)) { + hexPart = stringSlice(last, 2); + return hexPart === '' || !!exec(HEX, hexPart); + } + return false; +}; + +// https://url.spec.whatwg.org/#concept-ipv4-parser +var parseIPv4 = function (input) { + var parts = split(input, '.'); + var partsLength, numbers, index, part, radix, number, ipv4; + if (parts.length && parts[parts.length - 1] === '') { + parts.length--; + } + partsLength = parts.length; + if (partsLength > 4) return null; + numbers = []; + for (index = 0; index < partsLength; index++) { + part = parts[index]; + if (part === '') return null; + radix = 10; + if (part.length > 1 && charAt(part, 0) === '0') { + radix = exec(HEX_START, part) ? 16 : 8; + part = stringSlice(part, radix === 8 ? 1 : 2); + } + if (part === '') { + number = 0; + } else { + if (!exec(radix === 10 ? DEC : radix === 8 ? OCT : HEX, part)) return null; + number = parseInt(part, radix); + } + push(numbers, number); + } + for (index = 0; index < partsLength; index++) { + number = numbers[index]; + if (index === partsLength - 1) { + if (number >= pow(256, 5 - partsLength)) return null; + } else if (number > 255) return null; + } + ipv4 = pop(numbers); + for (index = 0; index < numbers.length; index++) { + ipv4 += numbers[index] * pow(256, 3 - index); + } + return ipv4; +}; + +// https://url.spec.whatwg.org/#concept-ipv6-parser +// eslint-disable-next-line max-statements -- TODO +var parseIPv6 = function (input) { + var address = [0, 0, 0, 0, 0, 0, 0, 0]; + var pieceIndex = 0; + var compress = null; + var pointer = 0; + var value, length, numbersSeen, ipv4Piece, number, swaps, swap; + + var chr = function () { + return charAt(input, pointer); + }; + + if (chr() === ':') { + if (charAt(input, 1) !== ':') return; + pointer += 2; + pieceIndex++; + compress = pieceIndex; + } + while (chr()) { + if (pieceIndex === 8) return; + if (chr() === ':') { + if (compress !== null) return; + pointer++; + pieceIndex++; + compress = pieceIndex; + continue; + } + value = length = 0; + while (length < 4 && exec(HEX, chr())) { + value = value * 16 + parseInt(chr(), 16); + pointer++; + length++; + } + if (chr() === '.') { + if (length === 0) return; + pointer -= length; + if (pieceIndex > 6) return; + numbersSeen = 0; + while (chr()) { + ipv4Piece = null; + if (numbersSeen > 0) { + if (chr() === '.' && numbersSeen < 4) pointer++; + else return; + } + if (!exec(DIGIT, chr())) return; + while (exec(DIGIT, chr())) { + number = parseInt(chr(), 10); + if (ipv4Piece === null) ipv4Piece = number; + else if (ipv4Piece === 0) return; + else ipv4Piece = ipv4Piece * 10 + number; + if (ipv4Piece > 255) return; + pointer++; + } + address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece; + numbersSeen++; + if (numbersSeen === 2 || numbersSeen === 4) pieceIndex++; + } + if (numbersSeen !== 4) return; + break; + } else if (chr() === ':') { + pointer++; + if (!chr()) return; + } else if (chr()) return; + address[pieceIndex++] = value; + } + if (compress !== null) { + swaps = pieceIndex - compress; + pieceIndex = 7; + while (pieceIndex !== 0 && swaps > 0) { + swap = address[pieceIndex]; + address[pieceIndex--] = address[compress + swaps - 1]; + address[compress + --swaps] = swap; + } + } else if (pieceIndex !== 8) return; + return address; +}; + +var findLongestZeroSequence = function (ipv6) { + var maxIndex = null; + var maxLength = 1; + var currStart = null; + var currLength = 0; + var index = 0; + for (; index < 8; index++) { + if (ipv6[index] !== 0) { + if (currLength > maxLength) { + maxIndex = currStart; + maxLength = currLength; + } + currStart = null; + currLength = 0; + } else { + if (currStart === null) currStart = index; + ++currLength; + } + } + return currLength > maxLength ? currStart : maxIndex; +}; + +// https://url.spec.whatwg.org/#host-serializing +var serializeHost = function (host) { + var result, index, compress, ignore0; + + // ipv4 + if (typeof host == 'number') { + result = []; + for (index = 0; index < 4; index++) { + unshift(result, host % 256); + host = floor(host / 256); + } + return join(result, '.'); + } + + // ipv6 + if (typeof host == 'object') { + result = ''; + compress = findLongestZeroSequence(host); + for (index = 0; index < 8; index++) { + if (ignore0 && host[index] === 0) continue; + if (ignore0) ignore0 = false; + if (compress === index) { + result += index ? ':' : '::'; + ignore0 = true; + } else { + result += numberToString(host[index], 16); + if (index < 7) result += ':'; + } + } + return '[' + result + ']'; + } + + return host; +}; + +var C0ControlPercentEncodeSet = {}; +var queryPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, { + ' ': 1, '"': 1, '#': 1, '<': 1, '>': 1 +}); +var specialQueryPercentEncodeSet = assign({}, queryPercentEncodeSet, { + "'": 1 +}); +var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, { + ' ': 1, '"': 1, '<': 1, '>': 1, '`': 1 +}); +var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, { + '#': 1, '?': 1, '{': 1, '}': 1, '^': 1 +}); +var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, { + '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1 +}); + +var percentEncode = function (chr, set) { + var code = codeAt(chr, 0); + // encodeURIComponent does not encode ', which is in the special-query percent-encode set + return code >= 0x20 && code < 0x7F && !hasOwn(set, chr) ? chr : chr === "'" && hasOwn(set, chr) ? '%27' : encodeURIComponent(chr); +}; + +// https://url.spec.whatwg.org/#special-scheme +var specialSchemes = { + ftp: 21, + file: null, + http: 80, + https: 443, + ws: 80, + wss: 443 +}; + +// https://url.spec.whatwg.org/#windows-drive-letter +var isWindowsDriveLetter = function (string, normalized) { + var second; + return string.length === 2 && exec(ALPHA, charAt(string, 0)) + && ((second = charAt(string, 1)) === ':' || (!normalized && second === '|')); +}; + +// https://url.spec.whatwg.org/#start-with-a-windows-drive-letter +var startsWithWindowsDriveLetter = function (string) { + var third; + return string.length > 1 && isWindowsDriveLetter(stringSlice(string, 0, 2)) && ( + string.length === 2 || + ((third = charAt(string, 2)) === '/' || third === '\\' || third === '?' || third === '#') + ); +}; + +// https://url.spec.whatwg.org/#single-dot-path-segment +var isSingleDot = function (segment) { + return segment === '.' || toLowerCase(segment) === '%2e'; +}; + +// https://url.spec.whatwg.org/#double-dot-path-segment +var isDoubleDot = function (segment) { + segment = toLowerCase(segment); + return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e'; +}; + +// States: +var SCHEME_START = {}; +var SCHEME = {}; +var NO_SCHEME = {}; +var SPECIAL_RELATIVE_OR_AUTHORITY = {}; +var PATH_OR_AUTHORITY = {}; +var RELATIVE = {}; +var RELATIVE_SLASH = {}; +var SPECIAL_AUTHORITY_SLASHES = {}; +var SPECIAL_AUTHORITY_IGNORE_SLASHES = {}; +var AUTHORITY = {}; +var HOST = {}; +var HOSTNAME = {}; +var PORT = {}; +var FILE = {}; +var FILE_SLASH = {}; +var FILE_HOST = {}; +var PATH_START = {}; +var PATH = {}; +var CANNOT_BE_A_BASE_URL_PATH = {}; +var QUERY = {}; +var FRAGMENT = {}; + +var URLState = function (url, isBase, base) { + var urlString = $toString(url); + var baseState, failure, searchParams; + if (isBase) { + failure = this.parse(urlString); + if (failure) throw new TypeError(failure); + this.searchParams = null; + } else { + if (base !== undefined) baseState = new URLState(base, true); + failure = this.parse(urlString, null, baseState); + if (failure) throw new TypeError(failure); + searchParams = getInternalSearchParamsState(new URLSearchParams()); + searchParams.bindURL(this); + this.searchParams = searchParams; + } +}; + +URLState.prototype = { + type: 'URL', + // https://url.spec.whatwg.org/#url-parsing + // eslint-disable-next-line max-statements -- TODO + parse: function (input, stateOverride, base) { + var url = this; + var state = stateOverride || SCHEME_START; + var pointer = 0; + var buffer = ''; + var seenAt = false; + var seenBracket = false; + var seenPasswordToken = false; + var codePoints, chr, bufferCodePoints, failure; + + input = $toString(input); + + if (!stateOverride) { + url.scheme = ''; + url.username = ''; + url.password = ''; + url.host = null; + url.port = null; + url.path = []; + url.query = null; + url.fragment = null; + url.cannotBeABaseURL = false; + input = replace(input, LEADING_C0_CONTROL_OR_SPACE, ''); + input = replace(input, TRAILING_C0_CONTROL_OR_SPACE, '$1'); + } + + input = replace(input, TAB_AND_NEW_LINE, ''); + + codePoints = arrayFrom(input); + + while (pointer <= codePoints.length) { + chr = codePoints[pointer]; + switch (state) { + case SCHEME_START: + if (chr && exec(ALPHA, chr)) { + buffer += toLowerCase(chr); + state = SCHEME; + } else if (!stateOverride) { + state = NO_SCHEME; + continue; + } else return INVALID_SCHEME; + break; + + case SCHEME: + if (chr && exec(ALPHANUMERIC_PLUS_MINUS_DOT, chr)) { + buffer += toLowerCase(chr); + } else if (chr === ':') { + if (stateOverride && ( + (url.isSpecial() !== hasOwn(specialSchemes, buffer)) || + (buffer === 'file' && (url.includesCredentials() || url.port !== null)) || + (url.scheme === 'file' && url.host === '') + )) return; + url.scheme = buffer; + if (stateOverride) { + if (url.isSpecial() && specialSchemes[url.scheme] === url.port) url.port = null; + return; + } + buffer = ''; + if (url.scheme === 'file') { + state = FILE; + } else if (url.isSpecial() && base && base.scheme === url.scheme) { + state = SPECIAL_RELATIVE_OR_AUTHORITY; + } else if (url.isSpecial()) { + state = SPECIAL_AUTHORITY_SLASHES; + } else if (codePoints[pointer + 1] === '/') { + state = PATH_OR_AUTHORITY; + pointer++; + } else { + url.cannotBeABaseURL = true; + push(url.path, ''); + state = CANNOT_BE_A_BASE_URL_PATH; + } + } else if (!stateOverride) { + buffer = ''; + state = NO_SCHEME; + pointer = 0; + continue; + } else return INVALID_SCHEME; + break; + + case NO_SCHEME: + if (!base || (base.cannotBeABaseURL && chr !== '#')) return INVALID_SCHEME; + if (base.cannotBeABaseURL && chr === '#') { + url.scheme = base.scheme; + url.path = arraySlice(base.path); + url.query = base.query; + url.fragment = ''; + url.cannotBeABaseURL = true; + state = FRAGMENT; + break; + } + state = base.scheme === 'file' ? FILE : RELATIVE; + continue; + + case SPECIAL_RELATIVE_OR_AUTHORITY: + if (chr === '/' && codePoints[pointer + 1] === '/') { + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + pointer++; + } else { + state = RELATIVE; + continue; + } break; + + case PATH_OR_AUTHORITY: + if (chr === '/') { + state = AUTHORITY; + break; + } else { + state = PATH; + continue; + } + + case RELATIVE: + url.scheme = base.scheme; + if (chr === EOF) { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = arraySlice(base.path); + url.query = base.query; + } else if (chr === '/' || (chr === '\\' && url.isSpecial())) { + state = RELATIVE_SLASH; + } else if (chr === '?') { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = arraySlice(base.path); + url.query = ''; + state = QUERY; + } else if (chr === '#') { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = arraySlice(base.path); + url.query = base.query; + url.fragment = ''; + state = FRAGMENT; + } else { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + url.path = arraySlice(base.path); + if (url.path.length) url.path.length--; + state = PATH; + continue; + } break; + + case RELATIVE_SLASH: + if (url.isSpecial() && (chr === '/' || chr === '\\')) { + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + } else if (chr === '/') { + state = AUTHORITY; + } else { + url.username = base.username; + url.password = base.password; + url.host = base.host; + url.port = base.port; + state = PATH; + continue; + } break; + + case SPECIAL_AUTHORITY_SLASHES: + state = SPECIAL_AUTHORITY_IGNORE_SLASHES; + if (chr !== '/' || codePoints[pointer + 1] !== '/') continue; + pointer++; + break; + + case SPECIAL_AUTHORITY_IGNORE_SLASHES: + if (chr !== '/' && chr !== '\\') { + state = AUTHORITY; + continue; + } break; + + case AUTHORITY: + if (chr === '@') { + if (seenAt) buffer = '%40' + buffer; + seenAt = true; + bufferCodePoints = arrayFrom(buffer); + for (var i = 0; i < bufferCodePoints.length; i++) { + var codePoint = bufferCodePoints[i]; + if (codePoint === ':' && !seenPasswordToken) { + seenPasswordToken = true; + continue; + } + var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet); + if (seenPasswordToken) url.password += encodedCodePoints; + else url.username += encodedCodePoints; + } + buffer = ''; + } else if ( + chr === EOF || chr === '/' || chr === '?' || chr === '#' || + (chr === '\\' && url.isSpecial()) + ) { + if (seenAt && buffer === '') return INVALID_AUTHORITY; + pointer -= arrayFrom(buffer).length + 1; + buffer = ''; + state = HOST; + } else buffer += chr; + break; + + case HOST: + case HOSTNAME: + if (stateOverride && url.scheme === 'file') { + state = FILE_HOST; + continue; + } else if (chr === ':' && !seenBracket) { + if (buffer === '') return INVALID_HOST; + if (stateOverride === HOSTNAME) return; + failure = url.parseHost(buffer); + if (failure) return failure; + buffer = ''; + state = PORT; + } else if ( + chr === EOF || chr === '/' || chr === '?' || chr === '#' || + (chr === '\\' && url.isSpecial()) + ) { + if (url.isSpecial() && buffer === '') return INVALID_HOST; + if (stateOverride && buffer === '' && (url.includesCredentials() || url.port !== null)) return; + failure = url.parseHost(buffer); + if (failure) return failure; + buffer = ''; + state = PATH_START; + if (stateOverride) return; + continue; + } else { + if (chr === '[') seenBracket = true; + else if (chr === ']') seenBracket = false; + buffer += chr; + } break; + + case PORT: + if (exec(DIGIT, chr)) { + buffer += chr; + } else if ( + chr === EOF || chr === '/' || chr === '?' || chr === '#' || + (chr === '\\' && url.isSpecial()) || + stateOverride + ) { + if (buffer !== '') { + var port = parseInt(buffer, 10); + if (port > 0xFFFF) return INVALID_PORT; + url.port = (url.isSpecial() && port === specialSchemes[url.scheme]) ? null : port; + buffer = ''; + } + if (stateOverride) return; + state = PATH_START; + continue; + } else return INVALID_PORT; + break; + + case FILE: + url.scheme = 'file'; + url.host = ''; + if (chr === '/' || chr === '\\') state = FILE_SLASH; + else if (base && base.scheme === 'file') { + switch (chr) { + case EOF: + url.host = base.host; + url.path = arraySlice(base.path); + url.query = base.query; + break; + case '?': + url.host = base.host; + url.path = arraySlice(base.path); + url.query = ''; + state = QUERY; + break; + case '#': + url.host = base.host; + url.path = arraySlice(base.path); + url.query = base.query; + url.fragment = ''; + state = FRAGMENT; + break; + default: + url.host = base.host; + if (!startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), ''))) { + url.path = arraySlice(base.path); + url.shortenPath(); + } + state = PATH; + continue; + } + } else { + state = PATH; + continue; + } break; + + case FILE_SLASH: + if (chr === '/' || chr === '\\') { + state = FILE_HOST; + break; + } + if (base && base.scheme === 'file') { + url.host = base.host; + if (!startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), '')) + && isWindowsDriveLetter(base.path[0], true)) push(url.path, base.path[0]); + } + state = PATH; + continue; + + case FILE_HOST: + if (chr === EOF || chr === '/' || chr === '\\' || chr === '?' || chr === '#') { + if (!stateOverride && isWindowsDriveLetter(buffer)) { + state = PATH; + } else if (buffer === '') { + url.host = ''; + if (stateOverride) return; + state = PATH_START; + } else { + failure = url.parseHost(buffer); + if (failure) return failure; + if (url.host === 'localhost') url.host = ''; + if (stateOverride) return; + buffer = ''; + state = PATH_START; + } continue; + } else buffer += chr; + break; + + case PATH_START: + if (url.isSpecial()) { + state = PATH; + if (chr !== '/' && chr !== '\\') continue; + } else if (!stateOverride && chr === '?') { + url.query = ''; + state = QUERY; + } else if (!stateOverride && chr === '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (chr !== EOF) { + state = PATH; + if (chr !== '/') continue; + } break; + + case PATH: + if ( + chr === EOF || chr === '/' || + (chr === '\\' && url.isSpecial()) || + (!stateOverride && (chr === '?' || chr === '#')) + ) { + if (isDoubleDot(buffer)) { + url.shortenPath(); + if (chr !== '/' && !(chr === '\\' && url.isSpecial())) { + push(url.path, ''); + } + } else if (isSingleDot(buffer)) { + if (chr !== '/' && !(chr === '\\' && url.isSpecial())) { + push(url.path, ''); + } + } else { + if (url.scheme === 'file' && !url.path.length && isWindowsDriveLetter(buffer)) { + if (url.host !== null && url.host !== '') url.host = ''; + buffer = charAt(buffer, 0) + ':'; // normalize windows drive letter + } + push(url.path, buffer); + } + buffer = ''; + if (url.scheme === 'file' && (chr === EOF || chr === '?' || chr === '#')) { + while (url.path.length > 1 && url.path[0] === '') { + shift(url.path); + } + } + if (chr === '?') { + url.query = ''; + state = QUERY; + } else if (chr === '#') { + url.fragment = ''; + state = FRAGMENT; + } + } else { + buffer += percentEncode(chr, pathPercentEncodeSet); + } break; + + case CANNOT_BE_A_BASE_URL_PATH: + if (chr === '?') { + url.query = ''; + state = QUERY; + } else if (chr === '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (chr !== EOF) { + url.path[0] += percentEncode(chr, C0ControlPercentEncodeSet); + } break; + + case QUERY: + if (!stateOverride && chr === '#') { + url.fragment = ''; + state = FRAGMENT; + } else if (chr !== EOF) { + url.query += percentEncode(chr, url.isSpecial() ? specialQueryPercentEncodeSet : queryPercentEncodeSet); + } break; + + case FRAGMENT: + if (chr !== EOF) url.fragment += percentEncode(chr, fragmentPercentEncodeSet); + break; + } + + pointer++; + } + }, + // https://url.spec.whatwg.org/#host-parsing + parseHost: function (input) { + var result, codePoints, index; + if (charAt(input, 0) === '[') { + if (charAt(input, input.length - 1) !== ']') return INVALID_HOST; + result = parseIPv6(stringSlice(input, 1, -1)); + if (!result) return INVALID_HOST; + this.host = result; + // opaque host + } else if (!this.isSpecial()) { + if (exec(FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT, input)) return INVALID_HOST; + result = ''; + codePoints = arrayFrom(input); + for (index = 0; index < codePoints.length; index++) { + result += percentEncode(codePoints[index], C0ControlPercentEncodeSet); + } + this.host = result; + } else { + input = toASCII(input); + if (exec(FORBIDDEN_HOST_CODE_POINT, input)) return INVALID_HOST; + if (endsInNumber(input)) { + result = parseIPv4(input); + if (result === null) return INVALID_HOST; + this.host = result; + } else { + this.host = input; + } + } + }, + // https://url.spec.whatwg.org/#cannot-have-a-username-password-port + cannotHaveUsernamePasswordPort: function () { + return this.host === null || this.host === '' || this.cannotBeABaseURL || this.scheme === 'file'; + }, + // https://url.spec.whatwg.org/#include-credentials + includesCredentials: function () { + return this.username !== '' || this.password !== ''; + }, + // https://url.spec.whatwg.org/#is-special + isSpecial: function () { + return hasOwn(specialSchemes, this.scheme); + }, + // https://url.spec.whatwg.org/#shorten-a-urls-path + shortenPath: function () { + var path = this.path; + var pathSize = path.length; + if (pathSize && (this.scheme !== 'file' || pathSize !== 1 || !isWindowsDriveLetter(path[0], true))) { + path.length--; + } + }, + // https://url.spec.whatwg.org/#concept-url-serializer + serialize: function () { + var url = this; + var scheme = url.scheme; + var username = url.username; + var password = url.password; + var host = url.host; + var port = url.port; + var path = url.path; + var query = url.query; + var fragment = url.fragment; + var output = scheme + ':'; + if (host !== null) { + output += '//'; + if (url.includesCredentials()) { + output += username + (password ? ':' + password : '') + '@'; + } + output += serializeHost(host); + if (port !== null) output += ':' + port; + } else if (scheme === 'file') output += '//'; + if (host === null && !url.cannotBeABaseURL && path.length > 1 && path[0] === '') output += '/.'; + output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + join(path, '/') : ''; + if (query !== null) output += '?' + query; + if (fragment !== null) output += '#' + fragment; + return output; + }, + // https://url.spec.whatwg.org/#dom-url-href + setHref: function (href) { + var failure = this.parse(href); + if (failure) throw new TypeError(failure); + this.searchParams.update(); + }, + // https://url.spec.whatwg.org/#dom-url-origin + getOrigin: function () { + var scheme = this.scheme; + var port = this.port; + if (scheme === 'blob') try { + return new URLConstructor(this.path[0]).origin; + } catch (error) { + return 'null'; + } + if (scheme === 'file' || !this.isSpecial()) return 'null'; + return scheme + '://' + serializeHost(this.host) + (port !== null ? ':' + port : ''); + }, + // https://url.spec.whatwg.org/#dom-url-protocol + getProtocol: function () { + return this.scheme + ':'; + }, + setProtocol: function (protocol) { + this.parse($toString(protocol) + ':', SCHEME_START); + }, + // https://url.spec.whatwg.org/#dom-url-username + getUsername: function () { + return this.username; + }, + setUsername: function (username) { + var codePoints = arrayFrom($toString(username)); + if (this.cannotHaveUsernamePasswordPort()) return; + this.username = ''; + for (var i = 0; i < codePoints.length; i++) { + this.username += percentEncode(codePoints[i], userinfoPercentEncodeSet); + } + }, + // https://url.spec.whatwg.org/#dom-url-password + getPassword: function () { + return this.password; + }, + setPassword: function (password) { + var codePoints = arrayFrom($toString(password)); + if (this.cannotHaveUsernamePasswordPort()) return; + this.password = ''; + for (var i = 0; i < codePoints.length; i++) { + this.password += percentEncode(codePoints[i], userinfoPercentEncodeSet); + } + }, + // https://url.spec.whatwg.org/#dom-url-host + getHost: function () { + var host = this.host; + var port = this.port; + return host === null ? '' + : port === null ? serializeHost(host) + : serializeHost(host) + ':' + port; + }, + setHost: function (host) { + if (this.cannotBeABaseURL) return; + this.parse(host, HOST); + }, + // https://url.spec.whatwg.org/#dom-url-hostname + getHostname: function () { + var host = this.host; + return host === null ? '' : serializeHost(host); + }, + setHostname: function (hostname) { + if (this.cannotBeABaseURL) return; + this.parse(hostname, HOSTNAME); + }, + // https://url.spec.whatwg.org/#dom-url-port + getPort: function () { + var port = this.port; + return port === null ? '' : $toString(port); + }, + setPort: function (port) { + if (this.cannotHaveUsernamePasswordPort()) return; + port = $toString(port); + if (port === '') this.port = null; + else this.parse(port, PORT); + }, + // https://url.spec.whatwg.org/#dom-url-pathname + getPathname: function () { + var path = this.path; + return this.cannotBeABaseURL ? path[0] : path.length ? '/' + join(path, '/') : ''; + }, + setPathname: function (pathname) { + if (this.cannotBeABaseURL) return; + this.path = []; + this.parse(pathname, PATH_START); + }, + // https://url.spec.whatwg.org/#dom-url-search + getSearch: function () { + var query = this.query; + return query ? '?' + query : ''; + }, + setSearch: function (search) { + search = $toString(search); + if (search === '') { + this.query = null; + } else { + if (charAt(search, 0) === '?') search = stringSlice(search, 1); + this.query = ''; + this.parse(search, QUERY); + } + this.searchParams.update(); + }, + // https://url.spec.whatwg.org/#dom-url-searchparams + getSearchParams: function () { + return this.searchParams.facade; + }, + // https://url.spec.whatwg.org/#dom-url-hash + getHash: function () { + var fragment = this.fragment; + return fragment ? '#' + fragment : ''; + }, + setHash: function (hash) { + hash = $toString(hash); + if (hash === '') { + this.fragment = null; + return; + } + if (charAt(hash, 0) === '#') hash = stringSlice(hash, 1); + this.fragment = ''; + this.parse(hash, FRAGMENT); + }, + update: function () { + this.query = this.searchParams.serialize() || null; + } +}; + +// `URL` constructor +// https://url.spec.whatwg.org/#url-class +var URLConstructor = function URL(url /* , base */) { + var that = anInstance(this, URLPrototype); + var base = validateArgumentsLength(arguments.length, 1) > 1 ? arguments[1] : undefined; + var state = setInternalState(that, new URLState(url, false, base)); + if (!DESCRIPTORS) { + that.href = state.serialize(); + that.origin = state.getOrigin(); + that.protocol = state.getProtocol(); + that.username = state.getUsername(); + that.password = state.getPassword(); + that.host = state.getHost(); + that.hostname = state.getHostname(); + that.port = state.getPort(); + that.pathname = state.getPathname(); + that.search = state.getSearch(); + that.searchParams = state.getSearchParams(); + that.hash = state.getHash(); + } +}; + +var URLPrototype = URLConstructor.prototype; + +var accessorDescriptor = function (getter, setter) { + return { + get: function () { + return getInternalURLState(this)[getter](); + }, + set: setter && function (value) { + return getInternalURLState(this)[setter](value); + }, + configurable: true, + enumerable: true + }; +}; + +if (DESCRIPTORS) { + // `URL.prototype.href` accessors pair + // https://url.spec.whatwg.org/#dom-url-href + defineBuiltInAccessor(URLPrototype, 'href', accessorDescriptor('serialize', 'setHref')); + // `URL.prototype.origin` getter + // https://url.spec.whatwg.org/#dom-url-origin + defineBuiltInAccessor(URLPrototype, 'origin', accessorDescriptor('getOrigin')); + // `URL.prototype.protocol` accessors pair + // https://url.spec.whatwg.org/#dom-url-protocol + defineBuiltInAccessor(URLPrototype, 'protocol', accessorDescriptor('getProtocol', 'setProtocol')); + // `URL.prototype.username` accessors pair + // https://url.spec.whatwg.org/#dom-url-username + defineBuiltInAccessor(URLPrototype, 'username', accessorDescriptor('getUsername', 'setUsername')); + // `URL.prototype.password` accessors pair + // https://url.spec.whatwg.org/#dom-url-password + defineBuiltInAccessor(URLPrototype, 'password', accessorDescriptor('getPassword', 'setPassword')); + // `URL.prototype.host` accessors pair + // https://url.spec.whatwg.org/#dom-url-host + defineBuiltInAccessor(URLPrototype, 'host', accessorDescriptor('getHost', 'setHost')); + // `URL.prototype.hostname` accessors pair + // https://url.spec.whatwg.org/#dom-url-hostname + defineBuiltInAccessor(URLPrototype, 'hostname', accessorDescriptor('getHostname', 'setHostname')); + // `URL.prototype.port` accessors pair + // https://url.spec.whatwg.org/#dom-url-port + defineBuiltInAccessor(URLPrototype, 'port', accessorDescriptor('getPort', 'setPort')); + // `URL.prototype.pathname` accessors pair + // https://url.spec.whatwg.org/#dom-url-pathname + defineBuiltInAccessor(URLPrototype, 'pathname', accessorDescriptor('getPathname', 'setPathname')); + // `URL.prototype.search` accessors pair + // https://url.spec.whatwg.org/#dom-url-search + defineBuiltInAccessor(URLPrototype, 'search', accessorDescriptor('getSearch', 'setSearch')); + // `URL.prototype.searchParams` getter + // https://url.spec.whatwg.org/#dom-url-searchparams + defineBuiltInAccessor(URLPrototype, 'searchParams', accessorDescriptor('getSearchParams')); + // `URL.prototype.hash` accessors pair + // https://url.spec.whatwg.org/#dom-url-hash + defineBuiltInAccessor(URLPrototype, 'hash', accessorDescriptor('getHash', 'setHash')); +} + +// `URL.prototype.toJSON` method +// https://url.spec.whatwg.org/#dom-url-tojson +defineBuiltIn(URLPrototype, 'toJSON', function toJSON() { + return getInternalURLState(this).serialize(); +}, { enumerable: true }); + +// `URL.prototype.toString` method +// https://url.spec.whatwg.org/#URL-stringification-behavior +defineBuiltIn(URLPrototype, 'toString', function toString() { + return getInternalURLState(this).serialize(); +}, { enumerable: true }); + +if (NativeURL) { + var nativeCreateObjectURL = NativeURL.createObjectURL; + var nativeRevokeObjectURL = NativeURL.revokeObjectURL; + // `URL.createObjectURL` method + // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL + if (nativeCreateObjectURL) defineBuiltIn(URLConstructor, 'createObjectURL', bind(nativeCreateObjectURL, NativeURL)); + // `URL.revokeObjectURL` method + // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL + if (nativeRevokeObjectURL) defineBuiltIn(URLConstructor, 'revokeObjectURL', bind(nativeRevokeObjectURL, NativeURL)); +} + +setToStringTag(URLConstructor, 'URL'); + +$({ global: true, constructor: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, { + URL: URLConstructor +}); + + +/***/ }), +/* 795 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(7); +var wellKnownSymbol = __webpack_require__(33); +var DESCRIPTORS = __webpack_require__(6); +var IS_PURE = __webpack_require__(36); + +var ITERATOR = wellKnownSymbol('iterator'); + +module.exports = !fails(function () { + // eslint-disable-next-line unicorn/relative-url-style -- required for testing + var url = new URL('b?a=1&b=2&c=3', 'https://a'); + var params = url.searchParams; + var params2 = new URLSearchParams('a=1&a=2&b=3'); + var result = ''; + url.pathname = 'c%20d'; + params.forEach(function (value, key) { + params['delete']('b'); + result += key + value; + }); + params2['delete']('a', 2); + // `undefined` case is a Chromium 117 bug + // https://bugs.chromium.org/p/v8/issues/detail?id=14222 + params2['delete']('b', undefined); + return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b'))) + || (!params.size && (IS_PURE || !DESCRIPTORS)) + || !params.sort + || url.href !== 'https://a/c%20d?a=1&c=3' + || params.get('c') !== '3' + || String(new URLSearchParams('?a=1')) !== 'a=1' + || !params[ITERATOR] + // throws in Edge + || new URL('https://a@b').username !== 'a' + || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b' + // not punycoded in Edge + || new URL('https://тест').host !== 'xn--e1aybc' + // not escaped in Chrome 62- + || new URL('https://a#б').hash !== '#%D0%B1' + // fails in Chrome 66- + || result !== 'a1c3' + // throws in Safari + || new URL('https://x', undefined).host !== 'x'; +}); + + +/***/ }), +/* 796 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js +var uncurryThis = __webpack_require__(14); + +var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1 +var base = 36; +var tMin = 1; +var tMax = 26; +var skew = 38; +var damp = 700; +var initialBias = 72; +var initialN = 128; // 0x80 +var delimiter = '-'; // '\x2D' +var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars +var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators +var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process'; +var baseMinusTMin = base - tMin; + +var $RangeError = RangeError; +var exec = uncurryThis(regexSeparators.exec); +var floor = Math.floor; +var fromCharCode = String.fromCharCode; +var charCodeAt = uncurryThis(''.charCodeAt); +var join = uncurryThis([].join); +var push = uncurryThis([].push); +var replace = uncurryThis(''.replace); +var split = uncurryThis(''.split); +var toLowerCase = uncurryThis(''.toLowerCase); + +/** + * Creates an array containing the numeric code points of each Unicode + * character in the string. While JavaScript uses UCS-2 internally, + * this function will convert a pair of surrogate halves (each of which + * UCS-2 exposes as separate characters) into a single code point, + * matching UTF-16. + */ +var ucs2decode = function (string) { + var output = []; + var counter = 0; + var length = string.length; + while (counter < length) { + var value = charCodeAt(string, counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // It's a high surrogate, and there is a next character. + var extra = charCodeAt(string, counter++); + if ((extra & 0xFC00) === 0xDC00) { // Low surrogate. + push(output, ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // It's an unmatched surrogate; only append this code unit, in case the + // next code unit is the high surrogate of a surrogate pair. + push(output, value); + counter--; + } + } else { + push(output, value); + } + } + return output; +}; + +/** + * Converts a digit/integer into a basic code point. + */ +var digitToBasic = function (digit) { + // 0..25 map to ASCII a..z or A..Z + // 26..35 map to ASCII 0..9 + return digit + 22 + 75 * (digit < 26); +}; + +/** + * Bias adaptation function as per section 3.4 of RFC 3492. + * https://tools.ietf.org/html/rfc3492#section-3.4 + */ +var adapt = function (delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + while (delta > baseMinusTMin * tMax >> 1) { + delta = floor(delta / baseMinusTMin); + k += base; + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); +}; + +/** + * Converts a string of Unicode symbols (e.g. a domain name label) to a + * Punycode string of ASCII-only symbols. + */ +var encode = function (input) { + var output = []; + + // Convert the input in UCS-2 to an array of Unicode code points. + input = ucs2decode(input); + + // Cache the length. + var inputLength = input.length; + + // Initialize the state. + var n = initialN; + var delta = 0; + var bias = initialBias; + var i, currentValue; + + // Handle the basic code points. + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue < 0x80) { + push(output, fromCharCode(currentValue)); + } + } + + var basicLength = output.length; // number of basic code points. + var handledCPCount = basicLength; // number of code points that have been handled; + + // Finish the basic string with a delimiter unless it's empty. + if (basicLength) { + push(output, delimiter); + } + + // Main encoding loop: + while (handledCPCount < inputLength) { + // All non-basic code points < n have been handled already. Find the next larger one: + var m = maxInt; + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + + // Increase `delta` enough to advance the decoder's state to , but guard against overflow. + var handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + throw new $RangeError(OVERFLOW_ERROR); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (i = 0; i < input.length; i++) { + currentValue = input[i]; + if (currentValue < n && ++delta > maxInt) { + throw new $RangeError(OVERFLOW_ERROR); + } + if (currentValue === n) { + // Represent delta as a generalized variable-length integer. + var q = delta; + var k = base; + while (true) { + var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias; + if (q < t) break; + var qMinusT = q - t; + var baseMinusT = base - t; + push(output, fromCharCode(digitToBasic(t + qMinusT % baseMinusT))); + q = floor(qMinusT / baseMinusT); + k += base; + } + + push(output, fromCharCode(digitToBasic(q))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength); + delta = 0; + handledCPCount++; + } + } + + delta++; + n++; + } + return join(output, ''); +}; + +module.exports = function (input) { + var encoded = []; + var labels = split(replace(toLowerCase(input), regexSeparators, '\u002E'), '.'); + var i, label; + for (i = 0; i < labels.length; i++) { + label = labels[i]; + push(encoded, exec(regexNonASCII, label) ? 'xn--' + encode(label) : label); + } + return join(encoded, '.'); +}; + + +/***/ }), +/* 797 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env` +__webpack_require__(175); +__webpack_require__(479); +var $ = __webpack_require__(3); +var globalThis = __webpack_require__(4); +var safeGetBuiltIn = __webpack_require__(386); +var getBuiltIn = __webpack_require__(23); +var call = __webpack_require__(8); +var uncurryThis = __webpack_require__(14); +var DESCRIPTORS = __webpack_require__(6); +var USE_NATIVE_URL = __webpack_require__(795); +var defineBuiltIn = __webpack_require__(47); +var defineBuiltInAccessor = __webpack_require__(77); +var defineBuiltIns = __webpack_require__(214); +var setToStringTag = __webpack_require__(82); +var createIteratorConstructor = __webpack_require__(177); +var InternalStateModule = __webpack_require__(51); +var anInstance = __webpack_require__(215); +var isCallable = __webpack_require__(21); +var hasOwn = __webpack_require__(38); +var bind = __webpack_require__(84); +var classof = __webpack_require__(69); +var anObject = __webpack_require__(46); +var isObject = __webpack_require__(20); +var $toString = __webpack_require__(68); +var create = __webpack_require__(71); +var createPropertyDescriptor = __webpack_require__(11); +var getIterator = __webpack_require__(139); +var getIteratorMethod = __webpack_require__(140); +var createIterResultObject = __webpack_require__(179); +var validateArgumentsLength = __webpack_require__(383); +var wellKnownSymbol = __webpack_require__(33); +var arraySort = __webpack_require__(195); + +var ITERATOR = wellKnownSymbol('iterator'); +var URL_SEARCH_PARAMS = 'URLSearchParams'; +var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS); +var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR); + +var nativeFetch = safeGetBuiltIn('fetch'); +var NativeRequest = safeGetBuiltIn('Request'); +var Headers = safeGetBuiltIn('Headers'); +var RequestPrototype = NativeRequest && NativeRequest.prototype; +var HeadersPrototype = Headers && Headers.prototype; +var TypeError = globalThis.TypeError; +var encodeURIComponent = globalThis.encodeURIComponent; +var fromCharCode = String.fromCharCode; +var fromCodePoint = getBuiltIn('String', 'fromCodePoint'); +var $parseInt = parseInt; +var charAt = uncurryThis(''.charAt); +var join = uncurryThis([].join); +var push = uncurryThis([].push); +var replace = uncurryThis(''.replace); +var shift = uncurryThis([].shift); +var splice = uncurryThis([].splice); +var split = uncurryThis(''.split); +var stringSlice = uncurryThis(''.slice); +var exec = uncurryThis(/./.exec); + +var plus = /\+/g; +var FALLBACK_REPLACER = '\uFFFD'; +var VALID_HEX = /^[0-9a-f]+$/i; + +var parseHexOctet = function (string, start) { + var substr = stringSlice(string, start, start + 2); + if (!exec(VALID_HEX, substr)) return NaN; + + return $parseInt(substr, 16); +}; + +var getLeadingOnes = function (octet) { + var count = 0; + for (var mask = 0x80; mask > 0 && (octet & mask) !== 0; mask >>= 1) { + count++; + } + return count; +}; + +var utf8Decode = function (octets) { + var codePoint = null; + var length = octets.length; + + switch (length) { + case 1: + codePoint = octets[0]; + break; + case 2: + codePoint = (octets[0] & 0x1F) << 6 | (octets[1] & 0x3F); + break; + case 3: + codePoint = (octets[0] & 0x0F) << 12 | (octets[1] & 0x3F) << 6 | (octets[2] & 0x3F); + break; + case 4: + codePoint = (octets[0] & 0x07) << 18 | (octets[1] & 0x3F) << 12 | (octets[2] & 0x3F) << 6 | (octets[3] & 0x3F); + break; + } + + // reject surrogates, overlong encodings, and out-of-range codepoints + if (codePoint === null + || codePoint > 0x10FFFF + || (codePoint >= 0xD800 && codePoint <= 0xDFFF) + || codePoint < (length > 3 ? 0x10000 : length > 2 ? 0x800 : length > 1 ? 0x80 : 0) + ) return null; + + return codePoint; +}; + +/* eslint-disable max-statements, max-depth -- ok */ +var decode = function (input) { + input = replace(input, plus, ' '); + var length = input.length; + var result = ''; + var i = 0; + + while (i < length) { + var decodedChar = charAt(input, i); + + if (decodedChar === '%') { + if (charAt(input, i + 1) === '%' || i + 3 > length) { + result += '%'; + i++; + continue; + } + + var octet = parseHexOctet(input, i + 1); + + // eslint-disable-next-line no-self-compare -- NaN check + if (octet !== octet) { + result += decodedChar; + i++; + continue; + } + + i += 2; + var byteSequenceLength = getLeadingOnes(octet); + + if (byteSequenceLength === 0) { + decodedChar = fromCharCode(octet); + } else { + if (byteSequenceLength === 1 || byteSequenceLength > 4) { + result += FALLBACK_REPLACER; + i++; + continue; + } + + var octets = [octet]; + var sequenceIndex = 1; + + while (sequenceIndex < byteSequenceLength) { + i++; + if (i + 3 > length || charAt(input, i) !== '%') break; + + var nextByte = parseHexOctet(input, i + 1); + + // eslint-disable-next-line no-self-compare -- NaN check + if (nextByte !== nextByte || nextByte > 191 || nextByte < 128) break; + + // https://encoding.spec.whatwg.org/#utf-8-decoder - position-specific byte ranges + if (sequenceIndex === 1) { + if (octet === 0xE0 && nextByte < 0xA0) break; + if (octet === 0xED && nextByte > 0x9F) break; + if (octet === 0xF0 && nextByte < 0x90) break; + if (octet === 0xF4 && nextByte > 0x8F) break; + } + + push(octets, nextByte); + i += 2; + sequenceIndex++; + } + + if (octets.length !== byteSequenceLength) { + result += FALLBACK_REPLACER; + continue; + } + + var codePoint = utf8Decode(octets); + if (codePoint === null) { + for (var replacement = 0; replacement < byteSequenceLength; replacement++) result += FALLBACK_REPLACER; + i++; + continue; + } else { + decodedChar = fromCodePoint(codePoint); + } + } + } + + result += decodedChar; + i++; + } + + return result; +}; +/* eslint-enable max-statements, max-depth -- ok */ + +var find = /[!'()~]|%20/g; + +var replacements = { + '!': '%21', + "'": '%27', + '(': '%28', + ')': '%29', + '~': '%7E', + '%20': '+' +}; + +var replacer = function (match) { + return replacements[match]; +}; + +var serialize = function (it) { + return replace(encodeURIComponent(it), find, replacer); +}; + +var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) { + setInternalState(this, { + type: URL_SEARCH_PARAMS_ITERATOR, + target: getInternalParamsState(params).entries, + index: 0, + kind: kind + }); +}, URL_SEARCH_PARAMS, function next() { + var state = getInternalIteratorState(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = null; + return createIterResultObject(undefined, true); + } + var entry = target[index]; + switch (state.kind) { + case 'keys': return createIterResultObject(entry.key, false); + case 'values': return createIterResultObject(entry.value, false); + } return createIterResultObject([entry.key, entry.value], false); +}, true); + +var URLSearchParamsState = function (init) { + this.entries = []; + this.url = null; + + if (init !== undefined) { + if (isObject(init)) this.parseObject(init); + else this.parseQuery(typeof init == 'string' ? charAt(init, 0) === '?' ? stringSlice(init, 1) : init : $toString(init)); + } +}; + +URLSearchParamsState.prototype = { + type: URL_SEARCH_PARAMS, + bindURL: function (url) { + this.url = url; + this.update(); + }, + parseObject: function (object) { + var entries = this.entries; + var iteratorMethod = getIteratorMethod(object); + var iterator, next, step, entryIterator, entryNext, first, second; + + if (iteratorMethod) { + iterator = getIterator(object, iteratorMethod); + next = iterator.next; + while (!(step = call(next, iterator)).done) { + entryIterator = getIterator(anObject(step.value)); + entryNext = entryIterator.next; + if ( + (first = call(entryNext, entryIterator)).done || + (second = call(entryNext, entryIterator)).done || + !call(entryNext, entryIterator).done + ) throw new TypeError('Expected sequence with length 2'); + push(entries, { key: $toString(first.value), value: $toString(second.value) }); + } + } else for (var key in object) if (hasOwn(object, key)) { + push(entries, { key: key, value: $toString(object[key]) }); + } + }, + parseQuery: function (query) { + if (query) { + var entries = this.entries; + var attributes = split(query, '&'); + var index = 0; + var attribute, entry; + while (index < attributes.length) { + attribute = attributes[index++]; + if (attribute.length) { + entry = split(attribute, '='); + push(entries, { + key: decode(shift(entry)), + value: decode(join(entry, '=')) + }); + } + } + } + }, + serialize: function () { + var entries = this.entries; + var result = []; + var index = 0; + var entry; + while (index < entries.length) { + entry = entries[index++]; + push(result, serialize(entry.key) + '=' + serialize(entry.value)); + } return join(result, '&'); + }, + update: function () { + this.entries.length = 0; + this.parseQuery(this.url.query); + }, + updateURL: function () { + if (this.url) this.url.update(); + } +}; + +// `URLSearchParams` constructor +// https://url.spec.whatwg.org/#interface-urlsearchparams +var URLSearchParamsConstructor = function URLSearchParams(/* init */) { + anInstance(this, URLSearchParamsPrototype); + var init = arguments.length > 0 ? arguments[0] : undefined; + var state = setInternalState(this, new URLSearchParamsState(init)); + if (!DESCRIPTORS) this.size = state.entries.length; +}; + +var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype; + +defineBuiltIns(URLSearchParamsPrototype, { + // `URLSearchParams.prototype.append` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-append + append: function append(name, value) { + var state = getInternalParamsState(this); + validateArgumentsLength(arguments.length, 2); + push(state.entries, { key: $toString(name), value: $toString(value) }); + if (!DESCRIPTORS) this.size++; + state.updateURL(); + }, + // `URLSearchParams.prototype.delete` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-delete + 'delete': function (name /* , value */) { + var state = getInternalParamsState(this); + var length = validateArgumentsLength(arguments.length, 1); + var entries = state.entries; + var key = $toString(name); + var $value = length < 2 ? undefined : arguments[1]; + var value = $value === undefined ? $value : $toString($value); + var index = 0; + while (index < entries.length) { + var entry = entries[index]; + if (entry.key === key && (value === undefined || entry.value === value)) { + splice(entries, index, 1); + } else index++; + } + if (!DESCRIPTORS) this.size = entries.length; + state.updateURL(); + }, + // `URLSearchParams.prototype.get` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-get + get: function get(name) { + var entries = getInternalParamsState(this).entries; + validateArgumentsLength(arguments.length, 1); + var key = $toString(name); + var index = 0; + for (; index < entries.length; index++) { + if (entries[index].key === key) return entries[index].value; + } + return null; + }, + // `URLSearchParams.prototype.getAll` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-getall + getAll: function getAll(name) { + var entries = getInternalParamsState(this).entries; + validateArgumentsLength(arguments.length, 1); + var key = $toString(name); + var result = []; + var index = 0; + for (; index < entries.length; index++) { + if (entries[index].key === key) push(result, entries[index].value); + } + return result; + }, + // `URLSearchParams.prototype.has` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-has + has: function has(name /* , value */) { + var entries = getInternalParamsState(this).entries; + var length = validateArgumentsLength(arguments.length, 1); + var key = $toString(name); + var $value = length < 2 ? undefined : arguments[1]; + var value = $value === undefined ? $value : $toString($value); + var index = 0; + while (index < entries.length) { + var entry = entries[index++]; + if (entry.key === key && (value === undefined || entry.value === value)) return true; + } + return false; + }, + // `URLSearchParams.prototype.set` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-set + set: function set(name, value) { + var state = getInternalParamsState(this); + validateArgumentsLength(arguments.length, 2); + var entries = state.entries; + var found = false; + var key = $toString(name); + var val = $toString(value); + var index = 0; + var entry; + for (; index < entries.length; index++) { + entry = entries[index]; + if (entry.key === key) { + if (found) splice(entries, index--, 1); + else { + found = true; + entry.value = val; + } + } + } + if (!found) push(entries, { key: key, value: val }); + if (!DESCRIPTORS) this.size = entries.length; + state.updateURL(); + }, + // `URLSearchParams.prototype.sort` method + // https://url.spec.whatwg.org/#dom-urlsearchparams-sort + sort: function sort() { + var state = getInternalParamsState(this); + arraySort(state.entries, function (a, b) { + return a.key > b.key ? 1 : -1; + }); + state.updateURL(); + }, + // `URLSearchParams.prototype.forEach` method + forEach: function forEach(callback /* , thisArg */) { + var entries = getInternalParamsState(this).entries; + var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined); + var index = 0; + var entry; + while (index < entries.length) { + entry = entries[index++]; + boundFunction(entry.value, entry.key, this); + } + }, + // `URLSearchParams.prototype.keys` method + keys: function keys() { + return new URLSearchParamsIterator(this, 'keys'); + }, + // `URLSearchParams.prototype.values` method + values: function values() { + return new URLSearchParamsIterator(this, 'values'); + }, + // `URLSearchParams.prototype.entries` method + entries: function entries() { + return new URLSearchParamsIterator(this, 'entries'); + } +}, { enumerable: true }); + +// `URLSearchParams.prototype[@@iterator]` method +defineBuiltIn(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries, { name: 'entries' }); + +// `URLSearchParams.prototype.toString` method +// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior +defineBuiltIn(URLSearchParamsPrototype, 'toString', function toString() { + return getInternalParamsState(this).serialize(); +}, { enumerable: true }); + +// `URLSearchParams.prototype.size` getter +// https://url.spec.whatwg.org/#dom-urlsearchparams-size +if (DESCRIPTORS) defineBuiltInAccessor(URLSearchParamsPrototype, 'size', { + get: function size() { + return getInternalParamsState(this).entries.length; + }, + configurable: true, + enumerable: true +}); + +setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS); + +$({ global: true, constructor: true, forced: !USE_NATIVE_URL }, { + URLSearchParams: URLSearchParamsConstructor +}); + +// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams` +if (!USE_NATIVE_URL && isCallable(Headers)) { + var headersHas = uncurryThis(HeadersPrototype.has); + var headersSet = uncurryThis(HeadersPrototype.set); + + var wrapRequestOptions = function (init) { + if (isObject(init)) { + var body = init.body; + var headers; + if (classof(body) === URL_SEARCH_PARAMS) { + headers = init.headers ? new Headers(init.headers) : new Headers(); + if (!headersHas(headers, 'content-type')) { + headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8'); + } + return create(init, { + body: createPropertyDescriptor(0, $toString(body)), + headers: createPropertyDescriptor(0, headers) + }); + } + } return init; + }; + + if (isCallable(nativeFetch)) { + $({ global: true, enumerable: true, dontCallGetSet: true, forced: true }, { + fetch: function fetch(input /* , init */) { + return nativeFetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {}); + } + }); + } + + if (isCallable(NativeRequest)) { + var RequestConstructor = function Request(input /* , init */) { + anInstance(this, RequestPrototype); + return new NativeRequest(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {}); + }; + + RequestPrototype.constructor = RequestConstructor; + RequestConstructor.prototype = RequestPrototype; + + $({ global: true, constructor: true, dontCallGetSet: true, forced: true }, { + Request: RequestConstructor + }); + } +} + +module.exports = { + URLSearchParams: URLSearchParamsConstructor, + getState: getInternalParamsState +}; + + +/***/ }), +/* 798 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var fails = __webpack_require__(7); +var validateArgumentsLength = __webpack_require__(383); +var toString = __webpack_require__(68); +var USE_NATIVE_URL = __webpack_require__(795); + +var URL = getBuiltIn('URL'); + +// https://github.com/nodejs/node/issues/47505 +// https://github.com/denoland/deno/issues/18893 +var THROWS_WITHOUT_ARGUMENTS = USE_NATIVE_URL && fails(function () { + URL.canParse(); +}); + +// Bun ~ 1.0.30 bug +// https://github.com/oven-sh/bun/issues/9250 +var WRONG_ARITY = fails(function () { + return URL.canParse.length !== 1; +}); + +// `URL.canParse` method +// https://url.spec.whatwg.org/#dom-url-canparse +$({ target: 'URL', stat: true, forced: !THROWS_WITHOUT_ARGUMENTS || WRONG_ARITY }, { + canParse: function canParse(url) { + var length = validateArgumentsLength(arguments.length, 1); + var urlString = toString(url); + var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]); + try { + return !!new URL(urlString, base); + } catch (error) { + return false; + } + } +}); + + +/***/ }), +/* 799 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var getBuiltIn = __webpack_require__(23); +var validateArgumentsLength = __webpack_require__(383); +var toString = __webpack_require__(68); +var USE_NATIVE_URL = __webpack_require__(795); + +var URL = getBuiltIn('URL'); + +// `URL.parse` method +// https://url.spec.whatwg.org/#dom-url-parse +$({ target: 'URL', stat: true, forced: !USE_NATIVE_URL }, { + parse: function parse(url) { + var length = validateArgumentsLength(arguments.length, 1); + var urlString = toString(url); + var base = length < 2 || arguments[1] === undefined ? undefined : toString(arguments[1]); + try { + return new URL(urlString, base); + } catch (error) { + return null; + } + } +}); + + +/***/ }), +/* 800 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3); +var call = __webpack_require__(8); + +// `URL.prototype.toJSON` method +// https://url.spec.whatwg.org/#dom-url-tojson +$({ target: 'URL', proto: true, enumerable: true }, { + toJSON: function toJSON() { + return call(URL.prototype.toString, this); + } +}); + + +/***/ }), +/* 801 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +// TODO: Remove this module from `core-js@4` since it's replaced to module below +__webpack_require__(797); + + +/***/ }), +/* 802 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineBuiltIn = __webpack_require__(47); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); +var validateArgumentsLength = __webpack_require__(383); + +var $URLSearchParams = URLSearchParams; +var URLSearchParamsPrototype = $URLSearchParams.prototype; +var append = uncurryThis(URLSearchParamsPrototype.append); +var $delete = uncurryThis(URLSearchParamsPrototype['delete']); +var forEach = uncurryThis(URLSearchParamsPrototype.forEach); +var push = uncurryThis([].push); +var params = new $URLSearchParams('a=1&a=2&b=3'); + +params['delete']('a', 1); +// `undefined` case is a Chromium 117 bug +// https://bugs.chromium.org/p/v8/issues/detail?id=14222 +params['delete']('b', undefined); + +if (params + '' !== 'a=2') { + defineBuiltIn(URLSearchParamsPrototype, 'delete', function (name /* , value */) { + var length = arguments.length; + var $value = length < 2 ? undefined : arguments[1]; + if (length && $value === undefined) return $delete(this, name); + var entries = []; + forEach(this, function (v, k) { // also validates `this` + push(entries, { key: k, value: v }); + }); + validateArgumentsLength(length, 1); + var key = toString(name); + var value = toString($value); + var index = 0; + var entriesLength = entries.length; + var entry; + while (index < entriesLength) { + entry = entries[index]; + $delete(this, entry.key); + index++; + } + index = 0; + while (index < entriesLength) { + entry = entries[index++]; + if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value); + } + }, { enumerable: true, unsafe: true }); +} + + +/***/ }), +/* 803 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var defineBuiltIn = __webpack_require__(47); +var uncurryThis = __webpack_require__(14); +var toString = __webpack_require__(68); +var validateArgumentsLength = __webpack_require__(383); + +var $URLSearchParams = URLSearchParams; +var URLSearchParamsPrototype = $URLSearchParams.prototype; +var getAll = uncurryThis(URLSearchParamsPrototype.getAll); +var $has = uncurryThis(URLSearchParamsPrototype.has); +var params = new $URLSearchParams('a=1'); + +// `undefined` case is a Chromium 117 bug +// https://bugs.chromium.org/p/v8/issues/detail?id=14222 +if (params.has('a', 2) || !params.has('a', undefined)) { + defineBuiltIn(URLSearchParamsPrototype, 'has', function has(name /* , value */) { + var length = arguments.length; + var $value = length < 2 ? undefined : arguments[1]; + if (length && $value === undefined) return $has(this, name); + var values = getAll(this, name); // also validates `this` + validateArgumentsLength(length, 1); + var value = toString($value); + var index = 0; + while (index < values.length) { + if (values[index++] === value) return true; + } return false; + }, { enumerable: true, unsafe: true }); +} + + +/***/ }), +/* 804 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(6); +var uncurryThis = __webpack_require__(14); +var defineBuiltInAccessor = __webpack_require__(77); + +var URLSearchParamsPrototype = URLSearchParams.prototype; +var forEach = uncurryThis(URLSearchParamsPrototype.forEach); + +// `URLSearchParams.prototype.size` getter +// https://github.com/whatwg/url/pull/734 +if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) { + defineBuiltInAccessor(URLSearchParamsPrototype, 'size', { + get: function size() { + var count = 0; + forEach(this, function () { count++; }); + return count; + }, + configurable: true, + enumerable: true + }); +} + + +/***/ }) +/******/ ]); }(); From c7f1d6675b9888de8895cc476009fbb1007b15ac Mon Sep 17 00:00:00 2001 From: "Namhyeon, Go" Date: Sat, 11 Apr 2026 12:42:07 +0900 Subject: [PATCH 21/31] Switch WSH output and update core-js Replace WScript.Echo with WScript.StdOut.WriteLine for WSH console output and reword provider comments to reflect requesting scripts (including LLM/AI services). Update core-js usage to app/assets/js/core-js-3.49.0.wsh and adjust related require paths (including squel), and remove the old core-js-3.26.1 minified file. Other minor changes include updates to bootstrap.bat and lib/http.js. --- app.js | 10 +++++----- app/assets/js/core-js-3.26.1.minified.js | 14 -------------- bootstrap.bat | 2 +- lib/http.js | 8 ++++---- 4 files changed, 10 insertions(+), 24 deletions(-) delete mode 100644 app/assets/js/core-js-3.26.1.minified.js diff --git a/app.js b/app.js index 1b61072..ff2de66 100644 --- a/app.js +++ b/app.js @@ -247,7 +247,7 @@ function TraceError(severity, message, callee) { })([ function (s) { fn.call(console, s); }, // 1) severity-specific console function (s) { console.log(s); }, // 2) generic console.log - function (s) { WScript.Echo(s); } // 3) WSH fallback + function (s) { WScript.StdOut.WriteLine(s); } // 3) WSH fallback ]); } @@ -413,7 +413,7 @@ function require(pathname) { if (pos > -1) { var scheme = FN.substring(0, pos); - // load script from a remote server + // request a script from a remote server if (["http", "https"].indexOf(scheme) > -1) { require._addScriptProvider(function(url) { try { @@ -424,7 +424,7 @@ function require(pathname) { }); } - // load script from LIE(Language Inference Engine) service + // request a script from LLM based AI services if (["ai"].indexOf(scheme) > -1) { require._addScriptProvider(function(url) { try { @@ -852,8 +852,8 @@ if (typeof JSON === "undefined") { __evalFile__("app/assets/js/json2.js"); } -// core-js (formerly, babel-polyfill) -require("app/assets/js/core-js-3.38.0.minified"); +// core-js (polyfills) +require("app/assets/js/core-js-3.49.0.wsh"); // Squel.js SQL query string builder for Javascript var squel = require("app/assets/js/squel-basic-5.13.0-afa1cb5.wsh"); diff --git a/app/assets/js/core-js-3.26.1.minified.js b/app/assets/js/core-js-3.26.1.minified.js deleted file mode 100644 index 565a39e..0000000 --- a/app/assets/js/core-js-3.26.1.minified.js +++ /dev/null @@ -1,14 +0,0 @@ -/** - * core-js 3.26.1 - * © 2014-2022 Denis Pushkarev (zloirock.ru) - * license: https://github.com/zloirock/core-js/blob/v3.26.1/LICENSE - * source: https://github.com/zloirock/core-js - */ -!function(t){"use strict";var r,e,n;r=[function(t,r,e){e(1),e(98),e(99),e(100),e(101),e(102),e(103),e(104),e(105),e(106),e(107),e(108),e(109),e(110),e(111),e(112),e(122),e(124),e(134),e(135),e(137),e(140),e(143),e(145),e(147),e(148),e(149),e(150),e(152),e(153),e(155),e(156),e(158),e(162),e(163),e(164),e(165),e(170),e(171),e(173),e(174),e(175),e(177),e(180),e(181),e(182),e(183),e(184),e(189),e(191),e(192),e(193),e(194),e(195),e(202),e(204),e(207),e(209),e(210),e(211),e(212),e(213),e(217),e(218),e(220),e(221),e(222),e(224),e(225),e(226),e(94),e(227),e(228),e(236),e(238),e(239),e(240),e(242),e(243),e(245),e(246),e(248),e(249),e(250),e(252),e(253),e(254),e(255),e(256),e(257),e(258),e(259),e(263),e(264),e(266),e(268),e(269),e(270),e(271),e(272),e(274),e(276),e(277),e(278),e(279),e(281),e(282),e(284),e(285),e(286),e(287),e(289),e(290),e(291),e(292),e(293),e(294),e(295),e(296),e(298),e(299),e(300),e(301),e(302),e(303),e(304),e(305),e(307),e(308),e(309),e(311),e(312),e(313),e(314),e(337),e(338),e(339),e(340),e(341),e(342),e(343),e(344),e(346),e(347),e(348),e(349),e(350),e(351),e(352),e(353),e(354),e(355),e(362),e(363),e(365),e(366),e(367),e(368),e(369),e(371),e(372),e(374),e(377),e(378),e(379),e(380),e(384),e(385),e(387),e(388),e(389),e(390),e(392),e(393),e(394),e(395),e(396),e(397),e(399),e(402),e(405),e(408),e(409),e(410),e(411),e(412),e(413),e(414),e(415),e(416),e(417),e(418),e(419),e(420),e(428),e(429),e(430),e(431),e(432),e(433),e(434),e(435),e(436),e(437),e(438),e(439),e(440),e(444),e(445),e(446),e(447),e(448),e(449),e(450),e(451),e(452),e(453),e(454),e(455),e(456),e(457),e(458),e(459),e(460),e(461),e(462),e(463),e(464),e(465),e(466),e(467),e(468),e(471),e(473),e(482),e(483),e(484),e(486),e(487),e(489),e(490),e(491),e(492),e(493),e(495),e(496),e(497),e(499),e(501),e(502),e(505),e(507),e(508),e(509),e(510),e(512),e(513),e(515),e(516),e(517),e(518),e(519),e(520),e(521),e(523),e(525),e(526),e(527),e(528),e(529),e(530),e(533),e(534),e(535),e(536),e(537),e(539),e(540),e(541),e(542),e(543),e(544),e(545),e(546),e(547),e(548),e(550),e(552),e(554),e(555),e(556),e(557),e(559),e(560),e(562),e(563),e(564),e(565),e(566),e(567),e(569),e(570),e(571),e(572),e(574),e(575),e(576),e(577),e(578),e(580),e(581),e(582),e(583),e(584),e(585),e(586),e(587),e(588),e(589),e(590),e(591),e(593),e(594),e(595),e(600),e(601),e(603),e(604),e(605),e(606),e(607),e(608),e(609),e(610),e(611),e(613),e(614),e(615),e(617),e(618),e(619),e(620),e(621),e(622),e(623),e(624),e(625),e(626),e(627),e(628),e(629),e(630),e(631),e(632),e(633),e(634),e(635),e(636),e(637),e(638),e(639),e(640),e(641),e(642),e(643),e(644),e(645),e(646),e(647),e(648),e(649),e(650),e(651),e(652),e(653),e(654),e(655),e(656),e(657),e(658),e(659),e(660),e(661),e(662),e(664),e(665),e(668),e(669),e(672),e(673),e(674),e(677),e(678),e(679),e(680),e(684),e(689),t.exports=e(690)},function(t,r,e){e(2),e(91),e(93),e(94),e(97)},function(r,e,n){var o=n(3),i=n(4),a=n(8),u=n(14),c=n(36),f=n(6),s=n(27),l=n(7),h=n(39),p=n(25),g=n(47),v=n(12),d=n(18),y=n(69),m=n(11),b=n(72),x=n(74),w=n(58),E=n(76),S=n(67),A=n(5),I=n(45),R=n(73),O=n(10),T=n(48),M=n(35),P=n(54),j=n(55),k=n(41),_=n(34),N=n(79),C=n(80),D=n(82),U=n(83),L=n(52),B=n(84).forEach,W=P("hidden"),z="Symbol",V=L.set,H=L.getterFor(z),q=Object.prototype,G=i.Symbol,K=G&&G.prototype,Y=i.TypeError,$=i.QObject,J=A.f,X=I.f,Q=E.f,Z=O.f,tt=u([].push),rt=M("symbols"),et=M("op-symbols"),nt=M("wks"),ot=!$||!$.prototype||!$.prototype.findChild,it=f&&l((function(){return 7!=b(X({},"a",{get:function(){return X(this,"a",{value:7}).a}})).a}))?function(t,r,e){var n=J(q,r);n&&delete q[r],X(t,r,e),n&&t!==q&&X(q,r,n)}:X,wrap=function(t,r){var e=rt[t]=b(K);return V(e,{type:z,tag:t,description:r}),f||(e.description=r),e},ut=function defineProperty(t,r,e){t===q&&ut(et,r,e),g(t);var n=d(r);return g(e),h(rt,n)?(e.enumerable?(h(t,W)&&t[W][n]&&(t[W][n]=!1),e=b(e,{enumerable:m(0,!1)})):(h(t,W)||X(t,W,m(1,{})),t[W][n]=!0),it(t,n,e)):X(t,n,e)},ct=function defineProperties(t,r){var e,n;return g(t),e=v(r),n=x(e).concat($getOwnPropertySymbols(e)),B(n,(function(r){f&&!a(ft,e,r)||ut(t,r,e[r])})),t},ft=function propertyIsEnumerable(t){var r=d(t),e=a(Z,this,r);return!(this===q&&h(rt,r)&&!h(et,r))&&(!(e||!h(this,r)||!h(rt,r)||h(this,W)&&this[W][r])||e)},st=function getOwnPropertyDescriptor(t,r){var e,n=v(t),o=d(r);if(n!==q||!h(rt,o)||h(et,o))return!(e=J(n,o))||!h(rt,o)||h(n,W)&&n[W][o]||(e.enumerable=!0),e},lt=function getOwnPropertyNames(t){var r=Q(v(t)),e=[];return B(r,(function(t){h(rt,t)||h(j,t)||tt(e,t)})),e},$getOwnPropertySymbols=function(t){var r=t===q,e=Q(r?et:v(t)),n=[];return B(e,(function(t){!h(rt,t)||r&&!h(q,t)||tt(n,rt[t])})),n};s||(G=function Symbol(){var r,e,n;if(p(K,this))throw Y("Symbol is not a constructor");return r=arguments.length&&arguments[0]!==t?y(arguments[0]):t,e=k(r),n=function(t){this===q&&a(n,et,t),h(this,W)&&h(this[W],e)&&(this[W][e]=!1),it(this,e,m(1,t))},f&&ot&&it(q,e,{configurable:!0,set:n}),wrap(e,r)},T(K=G.prototype,"toString",(function toString(){return H(this).tag})),T(G,"withoutSetter",(function(t){return wrap(k(t),t)})),O.f=ft,I.f=ut,R.f=ct,A.f=st,w.f=E.f=lt,S.f=$getOwnPropertySymbols,N.f=function(t){return wrap(_(t),t)},f&&(X(K,"description",{configurable:!0,get:function description(){return H(this).description}}),c||T(q,"propertyIsEnumerable",ft,{unsafe:!0}))),o({global:!0,constructor:!0,wrap:!0,forced:!s,sham:!s},{Symbol:G}),B(x(nt),(function(t){C(t)})),o({target:z,stat:!0,forced:!s},{useSetter:function(){ot=!0},useSimple:function(){ot=!1}}),o({target:"Object",stat:!0,forced:!s,sham:!f},{create:function create(r,e){return e===t?b(r):ct(b(r),e)},defineProperty:ut,defineProperties:ct,getOwnPropertyDescriptor:st}),o({target:"Object",stat:!0,forced:!s},{getOwnPropertyNames:lt}),D(),U(G,z),j[W]=!0},function(r,e,n){var o=n(4),i=n(5).f,a=n(44),u=n(48),c=n(38),f=n(56),s=n(68);r.exports=function(r,e){var n,l,h,p,g,v=r.target,d=r.global,y=r.stat;if(n=d?o:y?o[v]||c(v,{}):(o[v]||{}).prototype)for(l in e){if(p=e[l],h=r.dontCallGetSet?(g=i(n,l))&&g.value:n[l],!s(d?l:v+(y?".":"#")+l,r.forced)&&h!==t){if(typeof p==typeof h)continue;f(p,h)}(r.sham||h&&h.sham)&&a(p,"sham",!0),u(n,l,p,r)}}},function(t,r){var check=function(t){return t&&t.Math==Math&&t};t.exports=check("object"==typeof globalThis&&globalThis)||check("object"==typeof window&&window)||check("object"==typeof self&&self)||check("object"==typeof global&&global)||function(){return this}()||Function("return this")()},function(t,r,e){var n=e(6),o=e(8),i=e(10),a=e(11),u=e(12),c=e(18),f=e(39),s=e(42),l=Object.getOwnPropertyDescriptor;r.f=n?l:function getOwnPropertyDescriptor(t,r){if(t=u(t),r=c(r),s)try{return l(t,r)}catch(e){}if(f(t,r))return a(!o(i.f,t,r),t[r])}},function(t,r,e){var n=e(7);t.exports=!n((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]}))},function(t,r){t.exports=function(t){try{return!!t()}catch(r){return!0}}},function(t,r,e){var n=e(9),o=function(){}.call;t.exports=n?o.bind(o):function(){return o.apply(o,arguments)}},function(t,r,e){var n=e(7);t.exports=!n((function(){var t=function(){}.bind();return"function"!=typeof t||t.hasOwnProperty("prototype")}))},function(t,r,e){var n={}.propertyIsEnumerable,o=Object.getOwnPropertyDescriptor,i=o&&!n.call({1:2},1);r.f=i?function propertyIsEnumerable(t){var r=o(this,t);return!!r&&r.enumerable}:n},function(t,r){t.exports=function(t,r){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:r}}},function(t,r,e){var n=e(13),o=e(16);t.exports=function(t){return n(o(t))}},function(t,r,e){var n=e(14),o=e(7),i=e(15),a=Object,u=n("".split);t.exports=o((function(){return!a("z").propertyIsEnumerable(0)}))?function(t){return"String"==i(t)?u(t,""):a(t)}:a},function(t,r,e){var n=e(9),o=Function.prototype,i=o.call,a=n&&o.bind.bind(i,i);t.exports=n?a:function(t){return function(){return i.apply(t,arguments)}}},function(t,r,e){var n=e(14),o=n({}.toString),i=n("".slice);t.exports=function(t){return i(o(t),8,-1)}},function(t,r,e){var n=e(17),o=TypeError;t.exports=function(t){if(n(t))throw o("Can't call method on "+t);return t}},function(r,e){r.exports=function(r){return null===r||r===t}},function(t,r,e){var n=e(19),o=e(23);t.exports=function(t){var r=n(t,"string");return o(r)?r:r+""}},function(r,e,n){var o=n(8),i=n(20),a=n(23),u=n(30),c=n(33),f=n(34),s=TypeError,l=f("toPrimitive");r.exports=function(r,e){var n,f;if(!i(r)||a(r))return r;if(n=u(r,l)){if(e===t&&(e="default"),f=o(n,r,e),!i(f)||a(f))return f;throw s("Can't convert object to primitive value")}return e===t&&(e="number"),c(r,e)}},function(t,r,e){var n=e(21),o=e(22),i=o.all;t.exports=o.IS_HTMLDDA?function(t){return"object"==typeof t?null!==t:n(t)||t===i}:function(t){return"object"==typeof t?null!==t:n(t)}},function(t,r,e){var n=e(22),o=n.all;t.exports=n.IS_HTMLDDA?function(t){return"function"==typeof t||t===o}:function(t){return"function"==typeof t}},function(r,e){var n="object"==typeof document&&document.all;r.exports={all:n,IS_HTMLDDA:t===n&&n!==t}},function(t,r,e){var n=e(24),o=e(21),i=e(25),a=e(26),u=Object;t.exports=a?function(t){return"symbol"==typeof t}:function(t){var r=n("Symbol");return o(r)&&i(r.prototype,u(t))}},function(r,e,n){var o=n(4),i=n(21),aFunction=function(r){return i(r)?r:t};r.exports=function(t,r){return arguments.length<2?aFunction(o[t]):o[t]&&o[t][r]}},function(t,r,e){var n=e(14);t.exports=n({}.isPrototypeOf)},function(t,r,e){var n=e(27);t.exports=n&&!Symbol.sham&&"symbol"==typeof Symbol.iterator},function(t,r,e){var n=e(28),o=e(7);t.exports=!!Object.getOwnPropertySymbols&&!o((function(){var t=Symbol();return!String(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&n&&n<41}))},function(t,r,e){var n,o,i=e(4),a=e(29),u=i.process,c=i.Deno,f=u&&u.versions||c&&c.version,s=f&&f.v8;s&&(o=(n=s.split("."))[0]>0&&n[0]<4?1:+(n[0]+n[1])),!o&&a&&(!(n=a.match(/Edge\/(\d+)/))||n[1]>=74)&&(n=a.match(/Chrome\/(\d+)/))&&(o=+n[1]),t.exports=o},function(t,r,e){var n=e(24);t.exports=n("navigator","userAgent")||""},function(r,e,n){var o=n(31),i=n(17);r.exports=function(r,e){var n=r[e];return i(n)?t:o(n)}},function(t,r,e){var n=e(21),o=e(32),i=TypeError;t.exports=function(t){if(n(t))return t;throw i(o(t)+" is not a function")}},function(t,r){var e=String;t.exports=function(t){try{return e(t)}catch(r){return"Object"}}},function(t,r,e){var n=e(8),o=e(21),i=e(20),a=TypeError;t.exports=function(t,r){var e,u;if("string"===r&&o(e=t.toString)&&!i(u=n(e,t)))return u;if(o(e=t.valueOf)&&!i(u=n(e,t)))return u;if("string"!==r&&o(e=t.toString)&&!i(u=n(e,t)))return u;throw a("Can't convert object to primitive value")}},function(t,r,e){var n=e(4),o=e(35),i=e(39),a=e(41),u=e(27),c=e(26),f=o("wks"),s=n.Symbol,l=s&&s["for"],h=c?s:s&&s.withoutSetter||a;t.exports=function(t){if(!i(f,t)||!u&&"string"!=typeof f[t]){var r="Symbol."+t;f[t]=u&&i(s,t)?s[t]:c&&l?l(r):h(r)}return f[t]}},function(r,e,n){var o=n(36),i=n(37);(r.exports=function(r,e){return i[r]||(i[r]=e!==t?e:{})})("versions",[]).push({version:"3.26.1",mode:o?"pure":"global",copyright:"© 2014-2022 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.26.1/LICENSE",source:"https://github.com/zloirock/core-js"})},function(t,r){t.exports=!1},function(t,r,e){var n=e(4),o=e(38),i="__core-js_shared__",a=n[i]||o(i,{});t.exports=a},function(t,r,e){var n=e(4),o=Object.defineProperty;t.exports=function(t,r){try{o(n,t,{value:r,configurable:!0,writable:!0})}catch(e){n[t]=r}return r}},function(t,r,e){var n=e(14),o=e(40),i=n({}.hasOwnProperty);t.exports=Object.hasOwn||function hasOwn(t,r){return i(o(t),r)}},function(t,r,e){var n=e(16),o=Object;t.exports=function(t){return o(n(t))}},function(r,e,n){var o=n(14),i=0,a=Math.random(),u=o(1..toString);r.exports=function(r){return"Symbol("+(r===t?"":r)+")_"+u(++i+a,36)}},function(t,r,e){var n=e(6),o=e(7),i=e(43);t.exports=!n&&!o((function(){return 7!=Object.defineProperty(i("div"),"a",{get:function(){return 7}}).a}))},function(t,r,e){var n=e(4),o=e(20),i=n.document,a=o(i)&&o(i.createElement);t.exports=function(t){return a?i.createElement(t):{}}},function(t,r,e){var n=e(6),o=e(45),i=e(11);t.exports=n?function(t,r,e){return o.f(t,r,i(1,e))}:function(t,r,e){return t[r]=e,t}},function(t,r,e){var n=e(6),o=e(42),i=e(46),a=e(47),u=e(18),c=TypeError,f=Object.defineProperty,s=Object.getOwnPropertyDescriptor;r.f=n?i?function defineProperty(t,r,e){if(a(t),r=u(r),a(e),"function"==typeof t&&"prototype"===r&&"value"in e&&"writable"in e&&!e.writable){var n=s(t,r);n&&n.writable&&(t[r]=e.value,e={configurable:"configurable"in e?e.configurable:n.configurable,enumerable:"enumerable"in e?e.enumerable:n.enumerable,writable:!1})}return f(t,r,e)}:f:function defineProperty(t,r,e){if(a(t),r=u(r),a(e),o)try{return f(t,r,e)}catch(n){}if("get"in e||"set"in e)throw c("Accessors not supported");return"value"in e&&(t[r]=e.value),t}},function(t,r,e){var n=e(6),o=e(7);t.exports=n&&o((function(){return 42!=Object.defineProperty((function(){}),"prototype",{value:42,writable:!1}).prototype}))},function(t,r,e){var n=e(20),o=String,i=TypeError;t.exports=function(t){if(n(t))return t;throw i(o(t)+" is not an object")}},function(r,e,n){var o=n(21),i=n(45),a=n(49),u=n(38);r.exports=function(r,e,n,c){var f,s;if(c||(c={}),f=c.enumerable,s=c.name!==t?c.name:e,o(n)&&a(n,s,c),c.global)f?r[e]=n:u(e,n);else{try{c.unsafe?r[e]&&(f=!0):delete r[e]}catch(l){}f?r[e]=n:i.f(r,e,{value:n,enumerable:!1,configurable:!c.nonConfigurable,writable:!c.nonWritable})}return r}},function(r,e,n){var o=n(7),i=n(21),a=n(39),u=n(6),c=n(50).CONFIGURABLE,f=n(51),s=n(52),l=s.enforce,h=s.get,p=Object.defineProperty,g=u&&!o((function(){return 8!==p((function(){}),"length",{value:8}).length})),v=String(String).split("String"),d=r.exports=function(r,e,n){"Symbol("===String(e).slice(0,7)&&(e="["+String(e).replace(/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!a(r,"name")||c&&r.name!==e)&&(u?p(r,"name",{value:e,configurable:!0}):r.name=e),g&&n&&a(n,"arity")&&r.length!==n.arity&&p(r,"length",{value:n.arity});try{n&&a(n,"constructor")&&n.constructor?u&&p(r,"prototype",{writable:!1}):r.prototype&&(r.prototype=t)}catch(i){}var o=l(r);return a(o,"source")||(o.source=v.join("string"==typeof e?e:"")),r};Function.prototype.toString=d((function toString(){return i(this)&&h(this).source||f(this)}),"toString")},function(t,r,e){var n=e(6),o=e(39),i=Function.prototype,a=n&&Object.getOwnPropertyDescriptor,u=o(i,"name"),c=u&&"something"===function something(){}.name,f=u&&(!n||n&&a(i,"name").configurable);t.exports={EXISTS:u,PROPER:c,CONFIGURABLE:f}},function(t,r,e){var n=e(14),o=e(21),i=e(37),a=n(Function.toString);o(i.inspectSource)||(i.inspectSource=function(t){return a(t)}),t.exports=i.inspectSource},function(t,r,e){var n,o,i,a,u,c=e(53),f=e(4),s=e(20),l=e(44),h=e(39),p=e(37),g=e(54),v=e(55),d="Object already initialized",y=f.TypeError;c||p.state?((a=p.state||(p.state=new(0,f.WeakMap))).get=a.get,a.has=a.has,a.set=a.set,n=function(t,r){if(a.has(t))throw y(d);return r.facade=t,a.set(t,r),r},o=function(t){return a.get(t)||{}},i=function(t){return a.has(t)}):(v[u=g("state")]=!0,n=function(t,r){if(h(t,u))throw y(d);return r.facade=t,l(t,u,r),r},o=function(t){return h(t,u)?t[u]:{}},i=function(t){return h(t,u)}),t.exports={set:n,get:o,has:i,enforce:function(t){return i(t)?o(t):n(t,{})},getterFor:function(t){return function(r){var e;if(!s(r)||(e=o(r)).type!==t)throw y("Incompatible receiver, "+t+" required");return e}}}},function(t,r,e){var n=e(4),o=e(21),i=n.WeakMap;t.exports=o(i)&&/native code/.test(String(i))},function(t,r,e){var n=e(35),o=e(41),i=n("keys");t.exports=function(t){return i[t]||(i[t]=o(t))}},function(t,r){t.exports={}},function(t,r,e){var n=e(39),o=e(57),i=e(5),a=e(45);t.exports=function(t,r,e){var u,c,f=o(r),s=a.f,l=i.f;for(u=0;uf;)o(n,e=r[f++])&&(~a(s,e)||c(s,e));return s}},function(t,r,e){var n=e(12),o=e(61),i=e(64),createMethod=function(t){return function(r,e,a){var u,c=n(r),f=i(c),s=o(a,f);if(t&&e!=e){for(;f>s;)if((u=c[s++])!=u)return!0}else for(;f>s;s++)if((t||s in c)&&c[s]===e)return t||s||0;return!t&&-1}};t.exports={includes:createMethod(!0),indexOf:createMethod(!1)}},function(t,r,e){var n=e(62),o=Math.max,i=Math.min;t.exports=function(t,r){var e=n(t);return e<0?o(e+r,0):i(e,r)}},function(t,r,e){var n=e(63);t.exports=function(t){var r=+t;return r!=r||0===r?0:n(r)}},function(t,r){var e=Math.ceil,n=Math.floor;t.exports=Math.trunc||function trunc(t){var r=+t;return(r>0?n:e)(r)}},function(t,r,e){var n=e(65);t.exports=function(t){return n(t.length)}},function(t,r,e){var n=e(62),o=Math.min;t.exports=function(t){return t>0?o(n(t),9007199254740991):0}},function(t,r){t.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]},function(t,r){r.f=Object.getOwnPropertySymbols},function(t,r,e){var n=e(7),o=e(21),i=/#|\.prototype\./,isForced=function(t,r){var e=u[a(t)];return e==f||e!=c&&(o(r)?n(r):!!r)},a=isForced.normalize=function(t){return String(t).replace(i,".").toLowerCase()},u=isForced.data={},c=isForced.NATIVE="N",f=isForced.POLYFILL="P";t.exports=isForced},function(t,r,e){var n=e(70),o=String;t.exports=function(t){if("Symbol"===n(t))throw TypeError("Cannot convert a Symbol value to a string");return o(t)}},function(r,e,n){var o=n(71),i=n(21),a=n(15),u=n(34)("toStringTag"),c=Object,f="Arguments"==a(function(){return arguments}());r.exports=o?a:function(r){var e,n,o;return r===t?"Undefined":null===r?"Null":"string"==typeof(n=function(t,r){try{return t[r]}catch(e){}}(e=c(r),u))?n:f?a(e):"Object"==(o=a(e))&&i(e.callee)?"Arguments":o}},function(t,r,e){var n={};n[e(34)("toStringTag")]="z",t.exports="[object z]"===String(n)},function(r,e,n){var o,i=n(47),a=n(73),u=n(66),c=n(55),f=n(75),s=n(43),l=n(54)("IE_PROTO"),EmptyConstructor=function(){},scriptTag=function(t){return"